v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #4 from assimp/master 

Merge upstream changes.
pull/2158/head
ardenpm 2018-09-13 15:55:16 +10:00 committed by GitHub
parent 8518a5cda4 0066f3dafe
commit 32a85a972a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 17345 additions and 797 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
code/AssbinExporter.cpp
View File

@ -62,33 +62,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <time.h> #include <time.h>
using namespace Assimp;
namespace Assimp { namespace Assimp {
template <typename T> template <typename T>
size_t Write(IOStream * stream, const T& v) size_t Write(IOStream * stream, const T& v) {
{
return stream->Write( &v, sizeof(T), 1 ); return stream->Write( &v, sizeof(T), 1 );
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize an aiString // Serialize an aiString
template <> template <>
inline size_t Write<aiString>(IOStream * stream, const aiString& s) inline
{ size_t Write<aiString>(IOStream * stream, const aiString& s) {
const size_t s2 = (uint32_t)s.length; const size_t s2 = (uint32_t)s.length;
stream->Write(&s,4,1); stream->Write(&s,4,1);
stream->Write(s.data,s2,1); stream->Write(s.data,s2,1);
return s2+4; return s2+4;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize an unsigned int as uint32_t // Serialize an unsigned int as uint32_t
template <> template <>
inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) inline
{ size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) {
const uint32_t t = (uint32_t)w; const uint32_t t = (uint32_t)w;
if (w > t) { if (w > t) {
// this shouldn't happen, integers in Assimp data structures never exceed 2^32 // this shouldn't happen, integers in Assimp data structures never exceed 2^32
@ -96,114 +93,123 @@ inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w)
} }
stream->Write(&t,4,1); stream->Write(&t,4,1);
return 4; return 4;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize an unsigned int as uint16_t // Serialize an unsigned int as uint16_t
template <> template <>
inline size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) inline
{ size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) {
static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2"); static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
stream->Write(&w,2,1); stream->Write(&w,2,1);
return 2; return 2;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a float // Serialize a float
template <> template <>
inline size_t Write<float>(IOStream * stream, const float& f) inline
{ size_t Write<float>(IOStream * stream, const float& f) {
static_assert(sizeof(float)==4, "sizeof(float)==4"); static_assert(sizeof(float)==4, "sizeof(float)==4");
stream->Write(&f,4,1); stream->Write(&f,4,1);
return 4; return 4;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a double // Serialize a double
template <> template <>
inline size_t Write<double>(IOStream * stream, const double& f) inline
{ size_t Write<double>(IOStream * stream, const double& f) {
static_assert(sizeof(double)==8, "sizeof(double)==8"); static_assert(sizeof(double)==8, "sizeof(double)==8");
stream->Write(&f,8,1); stream->Write(&f,8,1);
return 8; return 8;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a vec3 // Serialize a vec3
template <> template <>
inline size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) inline
{ size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) {
size_t t = Write<float>(stream,v.x); size_t t = Write<float>(stream,v.x);
t += Write<float>(stream,v.y); t += Write<float>(stream,v.y);
t += Write<float>(stream,v.z); t += Write<float>(stream,v.z);
return t; return t;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a color value // Serialize a color value
template <> template <>
inline size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) inline
{ size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) {
size_t t = Write<float>(stream,v.r); size_t t = Write<float>(stream,v.r);
t += Write<float>(stream,v.g); t += Write<float>(stream,v.g);
t += Write<float>(stream,v.b); t += Write<float>(stream,v.b);
return t; return t;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a color value // Serialize a color value
template <> template <>
inline size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) inline
{ size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) {
size_t t = Write<float>(stream,v.r); size_t t = Write<float>(stream,v.r);
t += Write<float>(stream,v.g); t += Write<float>(stream,v.g);
t += Write<float>(stream,v.b); t += Write<float>(stream,v.b);
t += Write<float>(stream,v.a); t += Write<float>(stream,v.a);
return t; return t;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a quaternion // Serialize a quaternion
template <> template <>
inline size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) inline
{ size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) {
size_t t = Write<float>(stream,v.w); size_t t = Write<float>(stream,v.w);
t += Write<float>(stream,v.x); t += Write<float>(stream,v.x);
t += Write<float>(stream,v.y); t += Write<float>(stream,v.y);
t += Write<float>(stream,v.z); t += Write<float>(stream,v.z);
ai_assert(t == 16); ai_assert(t == 16);
return 16; return 16;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a vertex weight // Serialize a vertex weight
template <> template <>
inline size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) inline
{ size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) {
size_t t = Write<unsigned int>(stream,v.mVertexId); size_t t = Write<unsigned int>(stream,v.mVertexId);
return t+Write<float>(stream,v.mWeight); return t+Write<float>(stream,v.mWeight);
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize a mat4x4 // Serialize a mat4x4
template <> template <>
inline size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) inline
{ size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) {
for (unsigned int i = 0; i < 4;++i) { for (unsigned int i = 0; i < 4;++i) {
for (unsigned int i2 = 0; i2 < 4;++i2) { for (unsigned int i2 = 0; i2 < 4;++i2) {
Write<float>(stream,m[i][i2]); Write<float>(stream,m[i][i2]);
} }
} }
return 64; return 64;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize an aiVectorKey // Serialize an aiVectorKey
template <> template <>
inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) inline
{ size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) {
const size_t t = Write<double>(stream,v.mTime); const size_t t = Write<double>(stream,v.mTime);
return t + Write<aiVector3D>(stream,v.mValue); return t + Write<aiVector3D>(stream,v.mValue);
} }
@ -211,15 +217,15 @@ inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v)
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Serialize an aiQuatKey // Serialize an aiQuatKey
template <> template <>
inline size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) inline
{ size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) {
const size_t t = Write<double>(stream,v.mTime); const size_t t = Write<double>(stream,v.mTime);
return t + Write<aiQuaternion>(stream,v.mValue); return t + Write<aiQuaternion>(stream,v.mValue);
} }
template <typename T> template <typename T>
inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) inline
{ size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) {
T minc, maxc; T minc, maxc;
ArrayBounds(in,size,minc,maxc); ArrayBounds(in,size,minc,maxc);
@ -230,10 +236,11 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
// We use this to write out non-byte arrays so that we write using the specializations. // We use this to write out non-byte arrays so that we write using the specializations.
// This way we avoid writing out extra bytes that potentially come from struct alignment. // This way we avoid writing out extra bytes that potentially come from struct alignment.
template <typename T> template <typename T>
inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size) inline
{ size_t WriteArray(IOStream * stream, const T* in, unsigned int size) {
size_t n = 0; size_t n = 0;
for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]); for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
return n; return n;
} }
@ -293,19 +300,25 @@ inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
void * GetBufferPointer() { return buffer; } void * GetBufferPointer() { return buffer; }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) { return 0; } virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) { return aiReturn_FAILURE; } return 0;
virtual size_t Tell() const { return cursor; } }
virtual void Flush() { } virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
return aiReturn_FAILURE;
}
virtual size_t Tell() const {
return cursor;
}
virtual void Flush() {
// not implemented
}
virtual size_t FileSize() const virtual size_t FileSize() const {
{
return cursor; return cursor;
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) {
{
pSize *= pCount; pSize *= pCount;
if (cursor + pSize > cur_size) { if (cursor + pSize > cur_size) {
Grow(cursor + pSize); Grow(cursor + pSize);
@ -332,7 +345,6 @@ inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
bool compressed; bool compressed;
protected: protected:
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void WriteBinaryNode( IOStream * container, const aiNode* node) void WriteBinaryNode( IOStream * container, const aiNode* node)
{ {

11
code/AssbinExporter.h
View File

@ -46,6 +46,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_ASSBINEXPORTER_H_INC #ifndef AI_ASSBINEXPORTER_H_INC
#define AI_ASSBINEXPORTER_H_INC #define AI_ASSBINEXPORTER_H_INC
// nothing really needed here - reserved for future use like properties #include <assimp/defs.h>
#endif // nothing really needed here - reserved for future use like properties
namespace Assimp {
void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/);
}
#endif // AI_ASSBINEXPORTER_H_INC

235
code/AssbinLoader.cpp
View File

@ -79,16 +79,17 @@ static const aiImporterDesc desc = {
"assbin" "assbin"
}; };
const aiImporterDesc* AssbinImporter::GetInfo() const // -----------------------------------------------------------------------------------
{ const aiImporterDesc* AssbinImporter::GetInfo() const {
return &desc; return &desc;
} }
bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const // -----------------------------------------------------------------------------------
{ bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
IOStream * in = pIOHandler->Open(pFile); IOStream * in = pIOHandler->Open(pFile);
if (!in) if (nullptr == in) {
return false; return false;
}
char s[32]; char s[32];
in->Read( s, sizeof(char), 32 ); in->Read( s, sizeof(char), 32 );
@ -98,17 +99,17 @@ bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bo
return strncmp( s, "ASSIMP.binary-dump.", 19 ) == 0; return strncmp( s, "ASSIMP.binary-dump.", 19 ) == 0;
} }
// -----------------------------------------------------------------------------------
template <typename T> template <typename T>
T Read(IOStream * stream) T Read(IOStream * stream) {
{
T t; T t;
stream->Read( &t, sizeof(T), 1 ); stream->Read( &t, sizeof(T), 1 );
return t; return t;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiVector3D Read<aiVector3D>(IOStream * stream) aiVector3D Read<aiVector3D>(IOStream * stream) {
{
aiVector3D v; aiVector3D v;
v.x = Read<float>(stream); v.x = Read<float>(stream);
v.y = Read<float>(stream); v.y = Read<float>(stream);
@ -116,9 +117,9 @@ aiVector3D Read<aiVector3D>(IOStream * stream)
return v; return v;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiColor4D Read<aiColor4D>(IOStream * stream) aiColor4D Read<aiColor4D>(IOStream * stream) {
{
aiColor4D c; aiColor4D c;
c.r = Read<float>(stream); c.r = Read<float>(stream);
c.g = Read<float>(stream); c.g = Read<float>(stream);
@ -127,9 +128,9 @@ aiColor4D Read<aiColor4D>(IOStream * stream)
return c; return c;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiQuaternion Read<aiQuaternion>(IOStream * stream) aiQuaternion Read<aiQuaternion>(IOStream * stream) {
{
aiQuaternion v; aiQuaternion v;
v.w = Read<float>(stream); v.w = Read<float>(stream);
v.x = Read<float>(stream); v.x = Read<float>(stream);
@ -138,9 +139,9 @@ aiQuaternion Read<aiQuaternion>(IOStream * stream)
return v; return v;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiString Read<aiString>(IOStream * stream) aiString Read<aiString>(IOStream * stream) {
{
aiString s; aiString s;
stream->Read(&s.length,4,1); stream->Read(&s.length,4,1);
stream->Read(s.data,s.length,1); stream->Read(s.data,s.length,1);
@ -148,18 +149,18 @@ aiString Read<aiString>(IOStream * stream)
return s; return s;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiVertexWeight Read<aiVertexWeight>(IOStream * stream) aiVertexWeight Read<aiVertexWeight>(IOStream * stream) {
{
aiVertexWeight w; aiVertexWeight w;
w.mVertexId = Read<unsigned int>(stream); w.mVertexId = Read<unsigned int>(stream);
w.mWeight = Read<float>(stream); w.mWeight = Read<float>(stream);
return w; return w;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream) aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream) {
{
aiMatrix4x4 m; aiMatrix4x4 m;
for (unsigned int i = 0; i < 4;++i) { for (unsigned int i = 0; i < 4;++i) {
for (unsigned int i2 = 0; i2 < 4;++i2) { for (unsigned int i2 = 0; i2 < 4;++i2) {
@ -169,36 +170,43 @@ aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream)
return m; return m;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiVectorKey Read<aiVectorKey>(IOStream * stream) aiVectorKey Read<aiVectorKey>(IOStream * stream) {
{
aiVectorKey v; aiVectorKey v;
v.mTime = Read<double>(stream); v.mTime = Read<double>(stream);
v.mValue = Read<aiVector3D>(stream); v.mValue = Read<aiVector3D>(stream);
return v; return v;
} }
// -----------------------------------------------------------------------------------
template <> template <>
aiQuatKey Read<aiQuatKey>(IOStream * stream) aiQuatKey Read<aiQuatKey>(IOStream * stream) {
{
aiQuatKey v; aiQuatKey v;
v.mTime = Read<double>(stream); v.mTime = Read<double>(stream);
v.mValue = Read<aiQuaternion>(stream); v.mValue = Read<aiQuaternion>(stream);
return v; return v;
} }
// -----------------------------------------------------------------------------------
template <typename T> template <typename T>
void ReadArray(IOStream * stream, T * out, unsigned int size) void ReadArray( IOStream *stream, T * out, unsigned int size) {
{ ai_assert( nullptr != stream );
for (unsigned int i=0; i<size; i++) out[i] = Read<T>(stream); ai_assert( nullptr != out );
for (unsigned int i=0; i<size; i++) {
out[i] = Read<T>(stream);
}
} }
template <typename T> void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n ) // -----------------------------------------------------------------------------------
{ template <typename T>
void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n ) {
// not sure what to do here, the data isn't really useful. // not sure what to do here, the data isn't really useful.
stream->Seek( sizeof(T) * n, aiOrigin_CUR ); stream->Seek( sizeof(T) * n, aiOrigin_CUR );
} }
// -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* parent ) { void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* parent ) {
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
@ -273,8 +281,7 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* p
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b ) void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b ) {
{
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AIBONE); ai_assert(chunkID == ASSBIN_CHUNK_AIBONE);
@ -286,20 +293,22 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
// for the moment we write dumb min/max values for the bones, too. // for the moment we write dumb min/max values for the bones, too.
// maybe I'll add a better, hash-like solution later // maybe I'll add a better, hash-like solution later
if (shortened) if (shortened) {
{
ReadBounds(stream,b->mWeights,b->mNumWeights); ReadBounds(stream,b->mWeights,b->mNumWeights);
} // else write as usual } else {
else // else write as usual
{
b->mWeights = new aiVertexWeight[b->mNumWeights]; b->mWeights = new aiVertexWeight[b->mNumWeights];
ReadArray<aiVertexWeight>(stream,b->mWeights,b->mNumWeights); ReadArray<aiVertexWeight>(stream,b->mWeights,b->mNumWeights);
} }
} }
// -----------------------------------------------------------------------------------
static bool fitsIntoUI16(unsigned int mNumVertices) {
return ( mNumVertices < (1u<<16) );
}
void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) // -----------------------------------------------------------------------------------
{ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AIMESH); ai_assert(chunkID == ASSBIN_CHUNK_AIMESH);
@ -314,70 +323,61 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
// first of all, write bits for all existent vertex components // first of all, write bits for all existent vertex components
unsigned int c = Read<unsigned int>(stream); unsigned int c = Read<unsigned int>(stream);
if (c & ASSBIN_MESH_HAS_POSITIONS) if (c & ASSBIN_MESH_HAS_POSITIONS) {
{
if (shortened) { if (shortened) {
ReadBounds(stream,mesh->mVertices,mesh->mNumVertices); ReadBounds(stream,mesh->mVertices,mesh->mNumVertices);
} // else write as usual } else {
else // else write as usual
{
mesh->mVertices = new aiVector3D[mesh->mNumVertices]; mesh->mVertices = new aiVector3D[mesh->mNumVertices];
ReadArray<aiVector3D>(stream,mesh->mVertices,mesh->mNumVertices); ReadArray<aiVector3D>(stream,mesh->mVertices,mesh->mNumVertices);
} }
} }
if (c & ASSBIN_MESH_HAS_NORMALS) if (c & ASSBIN_MESH_HAS_NORMALS) {
{
if (shortened) { if (shortened) {
ReadBounds(stream,mesh->mNormals,mesh->mNumVertices); ReadBounds(stream,mesh->mNormals,mesh->mNumVertices);
} // else write as usual } else {
else // else write as usual
{
mesh->mNormals = new aiVector3D[mesh->mNumVertices]; mesh->mNormals = new aiVector3D[mesh->mNumVertices];
ReadArray<aiVector3D>(stream,mesh->mNormals,mesh->mNumVertices); ReadArray<aiVector3D>(stream,mesh->mNormals,mesh->mNumVertices);
} }
} }
if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) {
{
if (shortened) { if (shortened) {
ReadBounds(stream,mesh->mTangents,mesh->mNumVertices); ReadBounds(stream,mesh->mTangents,mesh->mNumVertices);
ReadBounds(stream,mesh->mBitangents,mesh->mNumVertices); ReadBounds(stream,mesh->mBitangents,mesh->mNumVertices);
} // else write as usual } else {
else // else write as usual
{
mesh->mTangents = new aiVector3D[mesh->mNumVertices]; mesh->mTangents = new aiVector3D[mesh->mNumVertices];
ReadArray<aiVector3D>(stream,mesh->mTangents,mesh->mNumVertices); ReadArray<aiVector3D>(stream,mesh->mTangents,mesh->mNumVertices);
mesh->mBitangents = new aiVector3D[mesh->mNumVertices]; mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
ReadArray<aiVector3D>(stream,mesh->mBitangents,mesh->mNumVertices); ReadArray<aiVector3D>(stream,mesh->mBitangents,mesh->mNumVertices);
} }
} }
for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
{ if (!(c & ASSBIN_MESH_HAS_COLOR(n))) {
if (!(c & ASSBIN_MESH_HAS_COLOR(n)))
break; break;
}
if (shortened) if (shortened) {
{
ReadBounds(stream,mesh->mColors[n],mesh->mNumVertices); ReadBounds(stream,mesh->mColors[n],mesh->mNumVertices);
} // else write as usual } else {
else // else write as usual
{
mesh->mColors[n] = new aiColor4D[mesh->mNumVertices]; mesh->mColors[n] = new aiColor4D[mesh->mNumVertices];
ReadArray<aiColor4D>(stream,mesh->mColors[n],mesh->mNumVertices); ReadArray<aiColor4D>(stream,mesh->mColors[n],mesh->mNumVertices);
} }
} }
for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
{ if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n))) {
if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n)))
break; break;
}
// write number of UV components // write number of UV components
mesh->mNumUVComponents[n] = Read<unsigned int>(stream); mesh->mNumUVComponents[n] = Read<unsigned int>(stream);
if (shortened) { if (shortened) {
ReadBounds(stream,mesh->mTextureCoords[n],mesh->mNumVertices); ReadBounds(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
} // else write as usual } else {
else // else write as usual
{
mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices]; mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
ReadArray<aiVector3D>(stream,mesh->mTextureCoords[n],mesh->mNumVertices); ReadArray<aiVector3D>(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
} }
@ -389,9 +389,8 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
// using Assimp's standard hashing function. // using Assimp's standard hashing function.
if (shortened) { if (shortened) {
Read<unsigned int>(stream); Read<unsigned int>(stream);
} } else {
else // else write as usual // else write as usual
{
// if there are less than 2^16 vertices, we can simply use 16 bit integers ... // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
mesh->mFaces = new aiFace[mesh->mNumFaces]; mesh->mFaces = new aiFace[mesh->mNumFaces];
for (unsigned int i = 0; i < mesh->mNumFaces;++i) { for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
@ -402,12 +401,10 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
f.mIndices = new unsigned int[f.mNumIndices]; f.mIndices = new unsigned int[f.mNumIndices];
for (unsigned int a = 0; a < f.mNumIndices;++a) { for (unsigned int a = 0; a < f.mNumIndices;++a) {
if (mesh->mNumVertices < (1u<<16)) // Check if unsigned short ( 16 bit ) are big enought for the indices
{ if ( fitsIntoUI16( mesh->mNumVertices ) ) {
f.mIndices[a] = Read<uint16_t>(stream); f.mIndices[a] = Read<uint16_t>(stream);
} } else {
else
{
f.mIndices[a] = Read<unsigned int>(stream); f.mIndices[a] = Read<unsigned int>(stream);
} }
} }
@ -424,8 +421,8 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
} }
} }
void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop) // -----------------------------------------------------------------------------------
{ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop) {
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIALPROPERTY); ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIALPROPERTY);
@ -442,8 +439,7 @@ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialPro
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat) void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat) {
{
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIAL); ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIAL);
@ -465,8 +461,7 @@ void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd) void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd) {
{
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AINODEANIM); ai_assert(chunkID == ASSBIN_CHUNK_AINODEANIM);
@ -493,9 +488,8 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
if (shortened) { if (shortened) {
ReadBounds(stream,nd->mRotationKeys,nd->mNumRotationKeys); ReadBounds(stream,nd->mRotationKeys,nd->mNumRotationKeys);
} // else write as usual } else {
else // else write as usual
{
nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys]; nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
ReadArray<aiQuatKey>(stream,nd->mRotationKeys,nd->mNumRotationKeys); ReadArray<aiQuatKey>(stream,nd->mRotationKeys,nd->mNumRotationKeys);
} }
@ -504,19 +498,16 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
if (shortened) { if (shortened) {
ReadBounds(stream,nd->mScalingKeys,nd->mNumScalingKeys); ReadBounds(stream,nd->mScalingKeys,nd->mNumScalingKeys);
} // else write as usual } else {
else // else write as usual
{
nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys]; nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
ReadArray<aiVectorKey>(stream,nd->mScalingKeys,nd->mNumScalingKeys); ReadArray<aiVectorKey>(stream,nd->mScalingKeys,nd->mNumScalingKeys);
} }
} }
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim ) void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim ) {
{
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AIANIMATION); ai_assert(chunkID == ASSBIN_CHUNK_AIANIMATION);
@ -527,8 +518,7 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
anim->mTicksPerSecond = Read<double> (stream); anim->mTicksPerSecond = Read<double> (stream);
anim->mNumChannels = Read<unsigned int>(stream); anim->mNumChannels = Read<unsigned int>(stream);
if (anim->mNumChannels) if (anim->mNumChannels) {
{
anim->mChannels = new aiNodeAnim*[ anim->mNumChannels ]; anim->mChannels = new aiNodeAnim*[ anim->mNumChannels ];
for (unsigned int a = 0; a < anim->mNumChannels;++a) { for (unsigned int a = 0; a < anim->mNumChannels;++a) {
anim->mChannels[a] = new aiNodeAnim(); anim->mChannels[a] = new aiNodeAnim();
@ -537,8 +527,8 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
} }
} }
void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) // -----------------------------------------------------------------------------------
{ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) {
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AITEXTURE); ai_assert(chunkID == ASSBIN_CHUNK_AITEXTURE);
@ -552,8 +542,7 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
if (!tex->mHeight) { if (!tex->mHeight) {
tex->pcData = new aiTexel[ tex->mWidth ]; tex->pcData = new aiTexel[ tex->mWidth ];
stream->Read(tex->pcData,1,tex->mWidth); stream->Read(tex->pcData,1,tex->mWidth);
} } else {
else {
tex->pcData = new aiTexel[ tex->mWidth*tex->mHeight ]; tex->pcData = new aiTexel[ tex->mWidth*tex->mHeight ];
stream->Read(tex->pcData,1,tex->mWidth*tex->mHeight*4); stream->Read(tex->pcData,1,tex->mWidth*tex->mHeight*4);
} }
@ -562,8 +551,7 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l ) void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l ) {
{
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AILIGHT); ai_assert(chunkID == ASSBIN_CHUNK_AILIGHT);
@ -586,12 +574,10 @@ void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
l->mAngleInnerCone = Read<float>(stream); l->mAngleInnerCone = Read<float>(stream);
l->mAngleOuterCone = Read<float>(stream); l->mAngleOuterCone = Read<float>(stream);
} }
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) {
{
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AICAMERA); ai_assert(chunkID == ASSBIN_CHUNK_AICAMERA);
@ -607,8 +593,8 @@ void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
cam->mAspect = Read<float>(stream); cam->mAspect = Read<float>(stream);
} }
void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene ) // -----------------------------------------------------------------------------------
{ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene ) {
uint32_t chunkID = Read<uint32_t>(stream); uint32_t chunkID = Read<uint32_t>(stream);
(void)(chunkID); (void)(chunkID);
ai_assert(chunkID == ASSBIN_CHUNK_AISCENE); ai_assert(chunkID == ASSBIN_CHUNK_AISCENE);
@ -623,12 +609,11 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
scene->mNumCameras = Read<unsigned int>(stream); scene->mNumCameras = Read<unsigned int>(stream);
// Read node graph // Read node graph
scene->mRootNode = new aiNode[1]; //scene->mRootNode = new aiNode[1];
ReadBinaryNode( stream, &scene->mRootNode, (aiNode*)NULL ); ReadBinaryNode( stream, &scene->mRootNode, (aiNode*)NULL );
// Read all meshes // Read all meshes
if (scene->mNumMeshes) if (scene->mNumMeshes) {
{
scene->mMeshes = new aiMesh*[scene->mNumMeshes]; scene->mMeshes = new aiMesh*[scene->mNumMeshes];
for (unsigned int i = 0; i < scene->mNumMeshes;++i) { for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
scene->mMeshes[i] = new aiMesh(); scene->mMeshes[i] = new aiMesh();
@ -637,8 +622,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
} }
// Read materials // Read materials
if (scene->mNumMaterials) if (scene->mNumMaterials) {
{
scene->mMaterials = new aiMaterial*[scene->mNumMaterials]; scene->mMaterials = new aiMaterial*[scene->mNumMaterials];
for (unsigned int i = 0; i< scene->mNumMaterials; ++i) { for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
scene->mMaterials[i] = new aiMaterial(); scene->mMaterials[i] = new aiMaterial();
@ -647,8 +631,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
} }
// Read all animations // Read all animations
if (scene->mNumAnimations) if (scene->mNumAnimations) {
{
scene->mAnimations = new aiAnimation*[scene->mNumAnimations]; scene->mAnimations = new aiAnimation*[scene->mNumAnimations];
for (unsigned int i = 0; i < scene->mNumAnimations;++i) { for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
scene->mAnimations[i] = new aiAnimation(); scene->mAnimations[i] = new aiAnimation();
@ -657,8 +640,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
} }
// Read all textures // Read all textures
if (scene->mNumTextures) if (scene->mNumTextures) {
{
scene->mTextures = new aiTexture*[scene->mNumTextures]; scene->mTextures = new aiTexture*[scene->mNumTextures];
for (unsigned int i = 0; i < scene->mNumTextures;++i) { for (unsigned int i = 0; i < scene->mNumTextures;++i) {
scene->mTextures[i] = new aiTexture(); scene->mTextures[i] = new aiTexture();
@ -667,8 +649,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
} }
// Read lights // Read lights
if (scene->mNumLights) if (scene->mNumLights) {
{
scene->mLights = new aiLight*[scene->mNumLights]; scene->mLights = new aiLight*[scene->mNumLights];
for (unsigned int i = 0; i < scene->mNumLights;++i) { for (unsigned int i = 0; i < scene->mNumLights;++i) {
scene->mLights[i] = new aiLight(); scene->mLights[i] = new aiLight();
@ -677,8 +658,7 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
} }
// Read cameras // Read cameras
if (scene->mNumCameras) if (scene->mNumCameras) {
{
scene->mCameras = new aiCamera*[scene->mNumCameras]; scene->mCameras = new aiCamera*[scene->mNumCameras];
for (unsigned int i = 0; i < scene->mNumCameras;++i) { for (unsigned int i = 0; i < scene->mNumCameras;++i) {
scene->mCameras[i] = new aiCamera(); scene->mCameras[i] = new aiCamera();
@ -688,16 +668,22 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
} }
void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) // -----------------------------------------------------------------------------------
{ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) {
IOStream * stream = pIOHandler->Open(pFile,"rb"); IOStream * stream = pIOHandler->Open(pFile,"rb");
if (!stream) if (nullptr == stream) {
return; return;
}
stream->Seek( 44, aiOrigin_CUR ); // signature // signature
stream->Seek( 44, aiOrigin_CUR );
unsigned int versionMajor = Read<unsigned int>(stream);
unsigned int versionMinor = Read<unsigned int>(stream);
if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) {
throw DeadlyImportError( "Invalid version, data format not compatible!" );
}
/*unsigned int versionMajor =*/ Read<unsigned int>(stream);
/*unsigned int versionMinor =*/ Read<unsigned int>(stream);
/*unsigned int versionRevision =*/ Read<unsigned int>(stream); /*unsigned int versionRevision =*/ Read<unsigned int>(stream);
/*unsigned int compileFlags =*/ Read<unsigned int>(stream); /*unsigned int compileFlags =*/ Read<unsigned int>(stream);
@ -711,8 +697,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
stream->Seek( 128, aiOrigin_CUR ); // options stream->Seek( 128, aiOrigin_CUR ); // options
stream->Seek( 64, aiOrigin_CUR ); // padding stream->Seek( 64, aiOrigin_CUR ); // padding
if (compressed) if (compressed) {
{
uLongf uncompressedSize = Read<uint32_t>(stream); uLongf uncompressedSize = Read<uint32_t>(stream);
uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell()); uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell());
@ -729,9 +714,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
delete[] uncompressedData; delete[] uncompressedData;
delete[] compressedData; delete[] compressedData;
} } else {
else
{
ReadBinaryScene(stream,pScene); ReadBinaryScene(stream,pScene);
} }

1
code/AssbinLoader.h
View File

@ -85,6 +85,7 @@ public:
aiScene* pScene, aiScene* pScene,
IOSystem* pIOHandler IOSystem* pIOHandler
); );
void ReadHeader();
void ReadBinaryScene( IOStream * stream, aiScene* pScene ); void ReadBinaryScene( IOStream * stream, aiScene* pScene );
void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent ); void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent );
void ReadBinaryMesh( IOStream * stream, aiMesh* mesh ); void ReadBinaryMesh( IOStream * stream, aiMesh* mesh );

2
code/Assimp.cpp
View File

@ -272,8 +272,6 @@ void aiReleaseImport( const aiScene* pScene)
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
aiReleaseDefaultMaterial();
// find the importer associated with this data // find the importer associated with this data
const ScenePrivateData* priv = ScenePriv(pScene); const ScenePrivateData* priv = ScenePriv(pScene);
if( !priv || !priv->mOrigImporter) { if( !priv || !priv->mOrigImporter) {

13
code/D3MFImporter.cpp
View File

@ -297,8 +297,9 @@ private:
return false; return false;
} }
//format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
const size_t len( strlen( color ) ); const size_t len( strlen( color ) );
if ( 9 != len ) { if ( 9 != len && 7 != len) {
return false; return false;
} }
@ -313,26 +314,28 @@ private:
++buf; ++buf;
comp[ 1 ] = *buf; comp[ 1 ] = *buf;
++buf; ++buf;
diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) ); diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) ) / 255.0;
comp[ 0 ] = *buf; comp[ 0 ] = *buf;
++buf; ++buf;
comp[ 1 ] = *buf; comp[ 1 ] = *buf;
++buf; ++buf;
diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) ); diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / 255.0;
comp[ 0 ] = *buf; comp[ 0 ] = *buf;
++buf; ++buf;
comp[ 1 ] = *buf; comp[ 1 ] = *buf;
++buf; ++buf;
diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) ); diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / 255.0;
if(7 == len)
return true;
comp[ 0 ] = *buf; comp[ 0 ] = *buf;
++buf; ++buf;
comp[ 1 ] = *buf; comp[ 1 ] = *buf;
++buf; ++buf;
diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) ); diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / 255.0;
return true; return true;
} }

2
code/Importer.cpp
View File

@ -178,7 +178,6 @@ Importer::~Importer()
{ {
// Delete all import plugins // Delete all import plugins
DeleteImporterInstanceList(pimpl->mImporter); DeleteImporterInstanceList(pimpl->mImporter);
aiReleaseDefaultMaterial();
// Delete all post-processing plug-ins // Delete all post-processing plug-ins
for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)
@ -385,7 +384,6 @@ void Importer::FreeScene( )
{ {
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
aiReleaseDefaultMaterial();
delete pimpl->mScene; delete pimpl->mScene;
pimpl->mScene = NULL; pimpl->mScene = NULL;

2
code/MDCLoader.cpp
View File

@ -434,11 +434,13 @@ void MDCImporter::InternReadFile(
else if (1 == pScene->mNumMeshes) else if (1 == pScene->mNumMeshes)
{ {
pScene->mRootNode = new aiNode(); pScene->mRootNode = new aiNode();
if ( nullptr != pScene->mMeshes[0] ) {
pScene->mRootNode->mName = pScene->mMeshes[0]->mName; pScene->mRootNode->mName = pScene->mMeshes[0]->mName;
pScene->mRootNode->mNumMeshes = 1; pScene->mRootNode->mNumMeshes = 1;
pScene->mRootNode->mMeshes = new unsigned int[1]; pScene->mRootNode->mMeshes = new unsigned int[1];
pScene->mRootNode->mMeshes[0] = 0; pScene->mRootNode->mMeshes[0] = 0;
} }
}
else else
{ {
pScene->mRootNode = new aiNode(); pScene->mRootNode = new aiNode();

20
code/MaterialSystem.cpp
View File

@ -387,26 +387,6 @@ aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
return AI_SUCCESS; return AI_SUCCESS;
} }
static aiMaterial *DefaultMaterial = nullptr;
// ------------------------------------------------------------------------------------------------
// Will return the default material.
aiMaterial *aiCreateAndRegisterDefaultMaterial() {
if (nullptr == DefaultMaterial) {
DefaultMaterial = new aiMaterial;
aiString s;
s.Set(AI_DEFAULT_MATERIAL_NAME);
DefaultMaterial->AddProperty(&s, AI_MATKEY_NAME);
}
return DefaultMaterial;
}
// ------------------------------------------------------------------------------------------------
// Will return the default material.
void aiReleaseDefaultMaterial() {
DefaultMaterial = nullptr;
}
static const unsigned int DefaultNumAllocated = 5; static const unsigned int DefaultNumAllocated = 5;

41
code/ObjFileImporter.cpp
View File

@ -211,12 +211,29 @@ void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene
} }
if (pModel->m_Objects.size() > 0) { if (pModel->m_Objects.size() > 0) {
unsigned int meshCount = 0;
unsigned int childCount = 0;
for(size_t index = 0; index < pModel->m_Objects.size(); ++index) {
if(pModel->m_Objects[index]) {
++childCount;
meshCount += (unsigned int)pModel->m_Objects[index]->m_Meshes.size();
}
}
// Allocate space for the child nodes on the root node
pScene->mRootNode->mChildren = new aiNode*[ childCount ];
// Create nodes for the whole scene // Create nodes for the whole scene
std::vector<aiMesh*> MeshArray; std::vector<aiMesh*> MeshArray;
MeshArray.reserve(meshCount);
for (size_t index = 0; index < pModel->m_Objects.size(); ++index) { for (size_t index = 0; index < pModel->m_Objects.size(); ++index) {
createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray); createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray);
} }
ai_assert(pScene->mRootNode->mNumChildren == childCount);
// Create mesh pointer buffer for this scene // Create mesh pointer buffer for this scene
if (pScene->mNumMeshes > 0) { if (pScene->mNumMeshes > 0) {
pScene->mMeshes = new aiMesh*[MeshArray.size()]; pScene->mMeshes = new aiMesh*[MeshArray.size()];
@ -287,9 +304,8 @@ aiNode *ObjFileImporter::createNodes(const ObjFile::Model* pModel, const ObjFile
pNode->mName = pObject->m_strObjName; pNode->mName = pObject->m_strObjName;
// If we have a parent node, store it // If we have a parent node, store it
if( pParent != NULL ) { ai_assert( NULL != pParent );
appendChildToParentNode( pParent, pNode ); appendChildToParentNode( pParent, pNode );
}
for ( size_t i=0; i< pObject->m_Meshes.size(); ++i ) { for ( size_t i=0; i< pObject->m_Meshes.size(); ++i ) {
unsigned int meshId = pObject->m_Meshes[ i ]; unsigned int meshId = pObject->m_Meshes[ i ];
@ -442,8 +458,8 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
pMesh->mNumVertices = numIndices; pMesh->mNumVertices = numIndices;
if (pMesh->mNumVertices == 0) { if (pMesh->mNumVertices == 0) {
throw DeadlyImportError( "OBJ: no vertices" ); throw DeadlyImportError( "OBJ: no vertices" );
} else if (pMesh->mNumVertices > AI_MAX_ALLOC(aiVector3D)) { } else if (pMesh->mNumVertices > AI_MAX_VERTICES) {
throw DeadlyImportError( "OBJ: Too many vertices, would run out of memory" ); throw DeadlyImportError( "OBJ: Too many vertices" );
} }
pMesh->mVertices = new aiVector3D[ pMesh->mNumVertices ]; pMesh->mVertices = new aiVector3D[ pMesh->mNumVertices ];
@ -770,25 +786,8 @@ void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild)
// Assign parent to child // Assign parent to child
pChild->mParent = pParent; pChild->mParent = pParent;
// If already children was assigned to the parent node, store them in a
std::vector<aiNode*> temp;
if (pParent->mChildren != NULL)
{
ai_assert( 0 != pParent->mNumChildren );
for (size_t index = 0; index < pParent->mNumChildren; index++)
{
temp.push_back(pParent->mChildren [ index ] );
}
delete [] pParent->mChildren;
}
// Copy node instances into parent node // Copy node instances into parent node
pParent->mNumChildren++; pParent->mNumChildren++;
pParent->mChildren = new aiNode*[ pParent->mNumChildren ];
for (size_t index = 0; index < pParent->mNumChildren-1; index++)
{
pParent->mChildren[ index ] = temp [ index ];
}
pParent->mChildren[ pParent->mNumChildren-1 ] = pChild; pParent->mChildren[ pParent->mNumChildren-1 ] = pChild;
} }

5
code/STLLoader.cpp
View File

@ -214,11 +214,10 @@ void STLImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
// create a single default material, using a white diffuse color for consistency with // create a single default material, using a white diffuse color for consistency with
// other geometric types (e.g., PLY). // other geometric types (e.g., PLY).
aiMaterial* pcMat = aiCreateAndRegisterDefaultMaterial(); aiMaterial* pcMat = new aiMaterial();
/*aiMaterial* pcMat = new aiMaterial();
aiString s; aiString s;
s.Set(AI_DEFAULT_MATERIAL_NAME); s.Set(AI_DEFAULT_MATERIAL_NAME);
pcMat->AddProperty(&s, AI_MATKEY_NAME);*/ pcMat->AddProperty(&s, AI_MATKEY_NAME);
aiColor4D clrDiffuse(ai_real(1.0),ai_real(1.0),ai_real(1.0),ai_real(1.0)); aiColor4D clrDiffuse(ai_real(1.0),ai_real(1.0),ai_real(1.0),ai_real(1.0));
if (bMatClr) { if (bMatClr) {

20
include/assimp/material.h
View File

@ -1565,26 +1565,6 @@ C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
unsigned int* flags /*= NULL*/); unsigned int* flags /*= NULL*/);
#endif // !#ifdef __cplusplus #endif // !#ifdef __cplusplus
// ---------------------------------------------------------------------------
/** @brief Helper function to get all values pertaining to a particular
* texture slot from a material structure.
*
* @return Pointer showing to the default material.
*/
// ---------------------------------------------------------------------------
#ifdef __cplusplus
ASSIMP_API aiMaterial *aiCreateAndRegisterDefaultMaterial(void);
#else
C_STRUCT aiMaterial *aiCreateAndRegisterDefaultMaterial(void);
#endif // !#ifdef __cplusplus
// ---------------------------------------------------------------------------
/**
* @brief Helper function to release the default material instance, the
* instance will not be destroyed.
*/
// ---------------------------------------------------------------------------
ASSIMP_API void aiReleaseDefaultMaterial();
#ifdef __cplusplus #ifdef __cplusplus
} }

67
port/PyAssimp/pyassimp/core.py
View File

@ -66,6 +66,13 @@ def make_tuple(ai_obj, type = None):
return res return res
# Returns unicode object for Python 2, and str object for Python 3.
def _convert_assimp_string(assimp_string):
try:
return unicode(assimp_string.data, errors='ignore')
except:
return str(assimp_string.data, errors='ignore')
# It is faster and more correct to have an init function for each assimp class # It is faster and more correct to have an init function for each assimp class
def _init_face(aiFace): def _init_face(aiFace):
aiFace.indices = [aiFace.mIndices[i] for i in range(aiFace.mNumIndices)] aiFace.indices = [aiFace.mIndices[i] for i in range(aiFace.mNumIndices)]
@ -118,12 +125,7 @@ def _init(self, target = None, parent = None):
continue continue
if m == 'mName': if m == 'mName':
obj = self.mName target.name = str(_convert_assimp_string(self.mName))
try:
uni = unicode(obj.data, errors='ignore')
except:
uni = str(obj.data, errors='ignore')
target.name = str( uni )
target.__class__.__repr__ = lambda x: str(x.__class__) + "(" + getattr(x, 'name','') + ")" target.__class__.__repr__ = lambda x: str(x.__class__) + "(" + getattr(x, 'name','') + ")"
target.__class__.__str__ = lambda x: getattr(x, 'name', '') target.__class__.__str__ = lambda x: getattr(x, 'name', '')
continue continue
@ -220,6 +222,9 @@ def _init(self, target = None, parent = None):
if isinstance(self, structs.Texture): if isinstance(self, structs.Texture):
_finalize_texture(self, target) _finalize_texture(self, target)
if isinstance(self, structs.Metadata):
_finalize_metadata(self, target)
return self return self
@ -412,6 +417,43 @@ def _finalize_mesh(mesh, target):
faces = [f.indices for f in target.faces] faces = [f.indices for f in target.faces]
setattr(target, 'faces', faces) setattr(target, 'faces', faces)
def _init_metadata_entry(entry):
from ctypes import POINTER, c_bool, c_int32, c_uint64, c_float, c_double, cast
entry.type = entry.mType
if entry.type == structs.MetadataEntry.AI_BOOL:
entry.data = cast(entry.mData, POINTER(c_bool)).contents.value
elif entry.type == structs.MetadataEntry.AI_INT32:
entry.data = cast(entry.mData, POINTER(c_int32)).contents.value
elif entry.type == structs.MetadataEntry.AI_UINT64:
entry.data = cast(entry.mData, POINTER(c_uint64)).contents.value
elif entry.type == structs.MetadataEntry.AI_FLOAT:
entry.data = cast(entry.mData, POINTER(c_float)).contents.value
elif entry.type == structs.MetadataEntry.AI_DOUBLE:
entry.data = cast(entry.mData, POINTER(c_double)).contents.value
elif entry.type == structs.MetadataEntry.AI_AISTRING:
assimp_string = cast(entry.mData, POINTER(structs.String)).contents
entry.data = _convert_assimp_string(assimp_string)
elif entry.type == structs.MetadataEntry.AI_AIVECTOR3D:
assimp_vector = cast(entry.mData, POINTER(structs.Vector3D)).contents
entry.data = make_tuple(assimp_vector)
return entry
def _finalize_metadata(metadata, target):
""" Building the metadata object is a bit specific.
Firstly, there are two separate arrays: one with metadata keys and one
with metadata values, and there are no corresponding mNum* attributes,
so the C arrays are not converted to Python arrays using the generic
code in the _init function.
Secondly, a metadata entry value has to be cast according to declared
metadata entry type.
"""
length = metadata.mNumProperties
setattr(target, 'keys', [str(_convert_assimp_string(metadata.mKeys[i])) for i in range(length)])
setattr(target, 'values', [_init_metadata_entry(metadata.mValues[i]) for i in range(length)])
class PropertyGetter(dict): class PropertyGetter(dict):
def __getitem__(self, key): def __getitem__(self, key):
@ -443,11 +485,8 @@ def _get_properties(properties, length):
for p in [properties[i] for i in range(length)]: for p in [properties[i] for i in range(length)]:
#the name #the name
p = p.contents p = p.contents
try: key = str(_convert_assimp_string(p.mKey))
uni = unicode(p.mKey.data, errors='ignore') key = (key.split('.')[1], p.mSemantic)
except:
uni = str(p.mKey.data, errors='ignore')
key = (str(uni).split('.')[1], p.mSemantic)
#the data #the data
from ctypes import POINTER, cast, c_int, c_float, sizeof from ctypes import POINTER, cast, c_int, c_float, sizeof
@ -455,11 +494,7 @@ def _get_properties(properties, length):
arr = cast(p.mData, POINTER(c_float * int(p.mDataLength/sizeof(c_float)) )).contents arr = cast(p.mData, POINTER(c_float * int(p.mDataLength/sizeof(c_float)) )).contents
value = [x for x in arr] value = [x for x in arr]
elif p.mType == 3: #string can't be an array elif p.mType == 3: #string can't be an array
try: value = _convert_assimp_string(cast(p.mData, POINTER(structs.MaterialPropertyString)).contents)
uni = unicode(cast(p.mData, POINTER(structs.MaterialPropertyString)).contents.data, errors='ignore')
except:
uni = str(cast(p.mData, POINTER(structs.MaterialPropertyString)).contents.data, errors='ignore')
value = uni
elif p.mType == 4: elif p.mType == 4:
arr = cast(p.mData, POINTER(c_int * int(p.mDataLength/sizeof(c_int)) )).contents arr = cast(p.mData, POINTER(c_int * int(p.mDataLength/sizeof(c_int)) )).contents

4
port/PyAssimp/pyassimp/structs.py
View File

@ -291,7 +291,7 @@ Node._fields_ = [
# Metadata associated with this node or NULL if there is no metadata. # Metadata associated with this node or NULL if there is no metadata.
# Whether any metadata is generated depends on the source file format. # Whether any metadata is generated depends on the source file format.
("mMetadata", POINTER(POINTER(Metadata))), ("mMetadata", POINTER(Metadata)),
] ]
class Light(Structure): class Light(Structure):
@ -939,7 +939,7 @@ class Scene(Structure):
# This data contains global metadata which belongs to the scene like # This data contains global metadata which belongs to the scene like
# unit-conversions, versions, vendors or other model-specific data. This # unit-conversions, versions, vendors or other model-specific data. This
# can be used to store format-specific metadata as well. # can be used to store format-specific metadata as well.
("mMetadata", POINTER(POINTER(Metadata))), ("mMetadata", POINTER(Metadata)),
] ]
assimp_structs_as_tuple = (Matrix4x4, assimp_structs_as_tuple = (Matrix4x4,

0
scripts/IFCImporter/CppGenerator.py → scripts/StepImporter/CppGenerator.py
View File

0
scripts/IFCImporter/ExpressReader.py → scripts/StepImporter/ExpressReader.py
View File

0
scripts/IFCImporter/IFCReaderGen.cpp.template → scripts/StepImporter/IFCReaderGen.cpp.template
View File

0
scripts/IFCImporter/IFCReaderGen.h.template → scripts/StepImporter/IFCReaderGen.h.template
View File

0
scripts/IFCImporter/entitylist.txt → scripts/StepImporter/entitylist.txt
View File

0
scripts/IFCImporter/genentitylist.sh → scripts/StepImporter/genentitylist.sh
View File

16378
scripts/StepImporter/schema_ap203e2_mim_lf.exp 100644
View File

File diff suppressed because it is too large Load Diff

0
scripts/IFCImporter/schema_ifc2x3.exp → scripts/StepImporter/schema_ifc2x3.exp
View File

0
scripts/IFCImporter/schema_ifc4.exp → scripts/StepImporter/schema_ifc4.exp
View File

2
test/CMakeLists.txt
View File

@ -113,6 +113,8 @@ SET( IMPORTERS
unit/utColladaImportExport.cpp unit/utColladaImportExport.cpp
unit/utCSMImportExport.cpp unit/utCSMImportExport.cpp
unit/utB3DImportExport.cpp unit/utB3DImportExport.cpp
unit/utMDCImportExport.cpp
unit/utAssbinImportExport.cpp
) )
SET( MATERIAL SET( MATERIAL

BIN
test/models/MDC/spider.mdc 100644
View File

Binary file not shown.

17
test/models/OBJ/point_cloud.obj 100644
View File

@ -0,0 +1,17 @@
####
#
# OBJ File Generated by Meshlab
#
####
# Object up.obj
#
# Vertices: 3
# Faces: 0
#
####
vn -0.281034 -0.057252 0.957989
v -0.207717 -0.953997 2.554110
vn -0.139126 -0.135672 0.980937
v -0.275607 -0.965401 2.541530
vn -0.163133 -0.131576 0.977791
v -0.270155 -0.963170 2.548000

78
test/unit/utAssbinImportExport.cpp 100644
View File

@ -0,0 +1,78 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2018, 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 "SceneDiffer.h"
#include "AbstractImportExportBase.h"
#include <assimp/Importer.hpp>
#include <assimp/Exporter.hpp>
#include <assimp/postprocess.h>
using namespace Assimp;
#ifndef ASSIMP_BUILD_NO_EXPORT
class utAssbinImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure );
Exporter exporter;
EXPECT_EQ( aiReturn_SUCCESS, exporter.Export( scene, "assbin", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_test.assbin" ) );
const aiScene *newScene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider_test.assbin", aiProcess_ValidateDataStructure );
return newScene != nullptr;
}
};
TEST_F( utAssbinImportExport, exportAssbin3DFromFileTest ) {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure );
EXPECT_NE( nullptr, scene );
}
TEST_F( utAssbinImportExport, import3ExportAssbinDFromFileTest ) {
EXPECT_TRUE( importerTest() );
}
#endif // #ifndef ASSIMP_BUILD_NO_EXPORT

63
test/unit/utMDCImportExport.cpp 100644
View File

@ -0,0 +1,63 @@
/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
Copyright (c) 2006-2018, 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 "AbstractImportExportBase.h"
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
using namespace Assimp;
class utMDCImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/MDC/spider.mdc", 0);
return true;
return nullptr != scene;
}
};
TEST_F( utMDCImportExport, importMDCFromFileTest ) {
EXPECT_TRUE( importerTest() );
}

10
test/unit/utMaterialSystem.cpp
View File

@ -129,18 +129,10 @@ TEST_F(MaterialSystemTest, testStringProperty) {
EXPECT_STREQ("Hello, this is a small test", s.data); EXPECT_STREQ("Hello, this is a small test", s.data);
} }
// ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testDefaultMaterialAccess) {
aiMaterial *mat = aiCreateAndRegisterDefaultMaterial();
EXPECT_NE(nullptr, mat);
aiReleaseDefaultMaterial();
delete mat;
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
TEST_F(MaterialSystemTest, testMaterialNameAccess) { TEST_F(MaterialSystemTest, testMaterialNameAccess) {
aiMaterial *mat = aiCreateAndRegisterDefaultMaterial(); aiMaterial *mat = new aiMaterial();
EXPECT_NE(nullptr, mat); EXPECT_NE(nullptr, mat);
aiString name = mat->GetName(); aiString name = mat->GetName();

7
test/unit/utObjImportExport.cpp
View File

@ -389,3 +389,10 @@ TEST_F( utObjImportExport, mtllib_after_g ) {
ASSERT_EQ(aiReturn_SUCCESS, mat->Get(AI_MATKEY_NAME, name)); ASSERT_EQ(aiReturn_SUCCESS, mat->Get(AI_MATKEY_NAME, name));
EXPECT_STREQ("MyMaterial", name.C_Str()); EXPECT_STREQ("MyMaterial", name.C_Str());
} }
TEST_F(utObjImportExport, import_point_cloud) {
::Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/point_cloud.obj", 0 );
ASSERT_NE(nullptr, scene);
}

14
test/unit/utSTLImportExport.cpp
View File

@ -67,6 +67,20 @@ TEST_F( utSTLImporterExporter, importSTLFromFileTest ) {
EXPECT_TRUE( importerTest() ); EXPECT_TRUE( importerTest() );
} }
TEST_F(utSTLImporterExporter, test_multiple) {
// import same file twice, each with its own importer
// must work both times and not crash
Assimp::Importer importer1;
const aiScene *scene1 = importer1.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/Spider_ascii.stl", aiProcess_ValidateDataStructure );
EXPECT_NE(nullptr, scene1);
Assimp::Importer importer2;
const aiScene *scene2 = importer2.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/Spider_ascii.stl", aiProcess_ValidateDataStructure );
EXPECT_NE(nullptr, scene2);
}
TEST_F( utSTLImporterExporter, test_with_two_solids ) { TEST_F( utSTLImporterExporter, test_with_two_solids ) {
Assimp::Importer importer; Assimp::Importer importer;
const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/triangle_with_two_solids.stl", aiProcess_ValidateDataStructure ); const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/STL/triangle_with_two_solids.stl", aiProcess_ValidateDataStructure );