| /* |
| --------------------------------------------------------------------------- |
| Open Asset Import Library (assimp) |
| --------------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, assimp team |
| |
| |
| All rights reserved. |
| |
| Redistribution and use of this software in source and binary forms, |
| with or without modification, are permitted provided that the following |
| conditions are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the |
| following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the |
| following disclaimer in the documentation and/or other |
| materials provided with the distribution. |
| |
| * Neither the name of the assimp team, nor the names of its |
| contributors may be used to endorse or promote products |
| derived from this software without specific prior |
| written permission of the assimp team. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| --------------------------------------------------------------------------- |
| */ |
| |
| /** @file Implementation of the XFile parser helper class */ |
| |
| |
| #ifndef ASSIMP_BUILD_NO_X_IMPORTER |
| |
| #include "XFileParser.h" |
| #include "XFileHelper.h" |
| #include "fast_atof.h" |
| #include "Exceptional.h" |
| #include "TinyFormatter.h" |
| #include "ByteSwapper.h" |
| #include "StringUtils.h" |
| #include <assimp/DefaultLogger.hpp> |
| |
| |
| using namespace Assimp; |
| using namespace Assimp::XFile; |
| using namespace Assimp::Formatter; |
| |
| #ifndef ASSIMP_BUILD_NO_COMPRESSED_X |
| |
| # ifdef ASSIMP_BUILD_NO_OWN_ZLIB |
| # include <zlib.h> |
| # else |
| # include "../contrib/zlib/zlib.h" |
| # endif |
| |
| // Magic identifier for MSZIP compressed data |
| #define MSZIP_MAGIC 0x4B43 |
| #define MSZIP_BLOCK 32786 |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Dummy memory wrappers for use with zlib |
| static void* dummy_alloc (void* /*opaque*/, unsigned int items, unsigned int size) { |
| return ::operator new(items*size); |
| } |
| |
| static void dummy_free (void* /*opaque*/, void* address) { |
| return ::operator delete(address); |
| } |
| |
| #endif // !! ASSIMP_BUILD_NO_COMPRESSED_X |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Constructor. Creates a data structure out of the XFile given in the memory block. |
| XFileParser::XFileParser( const std::vector<char>& pBuffer) |
| { |
| mMajorVersion = mMinorVersion = 0; |
| mIsBinaryFormat = false; |
| mBinaryNumCount = 0; |
| P = End = NULL; |
| mLineNumber = 0; |
| mScene = NULL; |
| |
| // vector to store uncompressed file for INFLATE'd X files |
| std::vector<char> uncompressed; |
| |
| // set up memory pointers |
| P = &pBuffer.front(); |
| End = P + pBuffer.size() - 1; |
| |
| // check header |
| if( strncmp( P, "xof ", 4) != 0) |
| throw DeadlyImportError( "Header mismatch, file is not an XFile."); |
| |
| // read version. It comes in a four byte format such as "0302" |
| mMajorVersion = (unsigned int)(P[4] - 48) * 10 + (unsigned int)(P[5] - 48); |
| mMinorVersion = (unsigned int)(P[6] - 48) * 10 + (unsigned int)(P[7] - 48); |
| |
| bool compressed = false; |
| |
| // txt - pure ASCII text format |
| if( strncmp( P + 8, "txt ", 4) == 0) |
| mIsBinaryFormat = false; |
| |
| // bin - Binary format |
| else if( strncmp( P + 8, "bin ", 4) == 0) |
| mIsBinaryFormat = true; |
| |
| // tzip - Inflate compressed text format |
| else if( strncmp( P + 8, "tzip", 4) == 0) |
| { |
| mIsBinaryFormat = false; |
| compressed = true; |
| } |
| // bzip - Inflate compressed binary format |
| else if( strncmp( P + 8, "bzip", 4) == 0) |
| { |
| mIsBinaryFormat = true; |
| compressed = true; |
| } |
| else ThrowException( format() << "Unsupported xfile format '" << |
| P[8] << P[9] << P[10] << P[11] << "'"); |
| |
| // float size |
| mBinaryFloatSize = (unsigned int)(P[12] - 48) * 1000 |
| + (unsigned int)(P[13] - 48) * 100 |
| + (unsigned int)(P[14] - 48) * 10 |
| + (unsigned int)(P[15] - 48); |
| |
| if( mBinaryFloatSize != 32 && mBinaryFloatSize != 64) |
| ThrowException( format() << "Unknown float size " << mBinaryFloatSize << " specified in xfile header." ); |
| |
| // The x format specifies size in bits, but we work in bytes |
| mBinaryFloatSize /= 8; |
| |
| P += 16; |
| |
| // If this is a compressed X file, apply the inflate algorithm to it |
| if (compressed) |
| { |
| #ifdef ASSIMP_BUILD_NO_COMPRESSED_X |
| throw DeadlyImportError("Assimp was built without compressed X support"); |
| #else |
| /* /////////////////////////////////////////////////////////////////////// |
| * COMPRESSED X FILE FORMAT |
| * /////////////////////////////////////////////////////////////////////// |
| * [xhead] |
| * 2 major |
| * 2 minor |
| * 4 type // bzip,tzip |
| * [mszip_master_head] |
| * 4 unkn // checksum? |
| * 2 unkn // flags? (seems to be constant) |
| * [mszip_head] |
| * 2 ofs // offset to next section |
| * 2 magic // 'CK' |
| * ... ofs bytes of data |
| * ... next mszip_head |
| * |
| * http://www.kdedevelopers.org/node/3181 has been very helpful. |
| * /////////////////////////////////////////////////////////////////////// |
| */ |
| |
| // build a zlib stream |
| z_stream stream; |
| stream.opaque = NULL; |
| stream.zalloc = &dummy_alloc; |
| stream.zfree = &dummy_free; |
| stream.data_type = (mIsBinaryFormat ? Z_BINARY : Z_ASCII); |
| |
| // initialize the inflation algorithm |
| ::inflateInit2(&stream, -MAX_WBITS); |
| |
| // skip unknown data (checksum, flags?) |
| P += 6; |
| |
| // First find out how much storage we'll need. Count sections. |
| const char* P1 = P; |
| unsigned int est_out = 0; |
| |
| while (P1 + 3 < End) |
| { |
| // read next offset |
| uint16_t ofs = *((uint16_t*)P1); |
| AI_SWAP2(ofs); P1 += 2; |
| |
| if (ofs >= MSZIP_BLOCK) |
| throw DeadlyImportError("X: Invalid offset to next MSZIP compressed block"); |
| |
| // check magic word |
| uint16_t magic = *((uint16_t*)P1); |
| AI_SWAP2(magic); P1 += 2; |
| |
| if (magic != MSZIP_MAGIC) |
| throw DeadlyImportError("X: Unsupported compressed format, expected MSZIP header"); |
| |
| // and advance to the next offset |
| P1 += ofs; |
| est_out += MSZIP_BLOCK; // one decompressed block is 32786 in size |
| } |
| |
| // Allocate storage and terminating zero and do the actual uncompressing |
| uncompressed.resize(est_out + 1); |
| char* out = &uncompressed.front(); |
| while (P + 3 < End) |
| { |
| uint16_t ofs = *((uint16_t*)P); |
| AI_SWAP2(ofs); |
| P += 4; |
| |
| if (P + ofs > End + 2) { |
| throw DeadlyImportError("X: Unexpected EOF in compressed chunk"); |
| } |
| |
| // push data to the stream |
| stream.next_in = (Bytef*)P; |
| stream.avail_in = ofs; |
| stream.next_out = (Bytef*)out; |
| stream.avail_out = MSZIP_BLOCK; |
| |
| // and decompress the data .... |
| int ret = ::inflate( &stream, Z_SYNC_FLUSH ); |
| if (ret != Z_OK && ret != Z_STREAM_END) |
| throw DeadlyImportError("X: Failed to decompress MSZIP-compressed data"); |
| |
| ::inflateReset( &stream ); |
| ::inflateSetDictionary( &stream, (const Bytef*)out , MSZIP_BLOCK - stream.avail_out ); |
| |
| // and advance to the next offset |
| out += MSZIP_BLOCK - stream.avail_out; |
| P += ofs; |
| } |
| |
| // terminate zlib |
| ::inflateEnd(&stream); |
| |
| // ok, update pointers to point to the uncompressed file data |
| P = &uncompressed[0]; |
| End = out; |
| |
| // FIXME: we don't need the compressed data anymore, could release |
| // it already for better memory usage. Consider breaking const-co. |
| DefaultLogger::get()->info("Successfully decompressed MSZIP-compressed file"); |
| #endif // !! ASSIMP_BUILD_NO_COMPRESSED_X |
| } |
| else |
| { |
| // start reading here |
| ReadUntilEndOfLine(); |
| } |
| |
| mScene = new Scene; |
| ParseFile(); |
| |
| // filter the imported hierarchy for some degenerated cases |
| if( mScene->mRootNode) { |
| FilterHierarchy( mScene->mRootNode); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Destructor. Destroys all imported data along with it |
| XFileParser::~XFileParser() |
| { |
| // kill everything we created |
| delete mScene; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseFile() |
| { |
| bool running = true; |
| while( running ) |
| { |
| // read name of next object |
| std::string objectName = GetNextToken(); |
| if (objectName.length() == 0) |
| break; |
| |
| // parse specific object |
| if( objectName == "template") |
| ParseDataObjectTemplate(); |
| else |
| if( objectName == "Frame") |
| ParseDataObjectFrame( NULL); |
| else |
| if( objectName == "Mesh") |
| { |
| // some meshes have no frames at all |
| Mesh* mesh = new Mesh; |
| ParseDataObjectMesh( mesh); |
| mScene->mGlobalMeshes.push_back( mesh); |
| } else |
| if( objectName == "AnimTicksPerSecond") |
| ParseDataObjectAnimTicksPerSecond(); |
| else |
| if( objectName == "AnimationSet") |
| ParseDataObjectAnimationSet(); |
| else |
| if( objectName == "Material") |
| { |
| // Material outside of a mesh or node |
| Material material; |
| ParseDataObjectMaterial( &material); |
| mScene->mGlobalMaterials.push_back( material); |
| } else |
| if( objectName == "}") |
| { |
| // whatever? |
| DefaultLogger::get()->warn("} found in dataObject"); |
| } else |
| { |
| // unknown format |
| DefaultLogger::get()->warn("Unknown data object in animation of .x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectTemplate() |
| { |
| // parse a template data object. Currently not stored. |
| std::string name; |
| readHeadOfDataObject( &name); |
| |
| // read GUID |
| std::string guid = GetNextToken(); |
| |
| // read and ignore data members |
| bool running = true; |
| while ( running ) |
| { |
| std::string s = GetNextToken(); |
| |
| if( s == "}") |
| break; |
| |
| if( s.length() == 0) |
| ThrowException( "Unexpected end of file reached while parsing template definition"); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectFrame( Node* pParent) |
| { |
| // A coordinate frame, or "frame of reference." The Frame template |
| // is open and can contain any object. The Direct3D extensions (D3DX) |
| // mesh-loading functions recognize Mesh, FrameTransformMatrix, and |
| // Frame template instances as child objects when loading a Frame |
| // instance. |
| std::string name; |
| readHeadOfDataObject(&name); |
| |
| // create a named node and place it at its parent, if given |
| Node* node = new Node( pParent); |
| node->mName = name; |
| if( pParent) |
| { |
| pParent->mChildren.push_back( node); |
| } else |
| { |
| // there might be multiple root nodes |
| if( mScene->mRootNode != NULL) |
| { |
| // place a dummy root if not there |
| if( mScene->mRootNode->mName != "$dummy_root") |
| { |
| Node* exroot = mScene->mRootNode; |
| mScene->mRootNode = new Node( NULL); |
| mScene->mRootNode->mName = "$dummy_root"; |
| mScene->mRootNode->mChildren.push_back( exroot); |
| exroot->mParent = mScene->mRootNode; |
| } |
| // put the new node as its child instead |
| mScene->mRootNode->mChildren.push_back( node); |
| node->mParent = mScene->mRootNode; |
| } else |
| { |
| // it's the first node imported. place it as root |
| mScene->mRootNode = node; |
| } |
| } |
| |
| // Now inside a frame. |
| // read tokens until closing brace is reached. |
| bool running = true; |
| while ( running ) |
| { |
| std::string objectName = GetNextToken(); |
| if (objectName.size() == 0) |
| ThrowException( "Unexpected end of file reached while parsing frame"); |
| |
| if( objectName == "}") |
| break; // frame finished |
| else |
| if( objectName == "Frame") |
| ParseDataObjectFrame( node); // child frame |
| else |
| if( objectName == "FrameTransformMatrix") |
| ParseDataObjectTransformationMatrix( node->mTrafoMatrix); |
| else |
| if( objectName == "Mesh") |
| { |
| Mesh* mesh = new Mesh(name); |
| node->mMeshes.push_back( mesh); |
| ParseDataObjectMesh( mesh); |
| } else |
| { |
| DefaultLogger::get()->warn("Unknown data object in frame in x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectTransformationMatrix( aiMatrix4x4& pMatrix) |
| { |
| // read header, we're not interested if it has a name |
| readHeadOfDataObject(); |
| |
| // read its components |
| pMatrix.a1 = ReadFloat(); pMatrix.b1 = ReadFloat(); |
| pMatrix.c1 = ReadFloat(); pMatrix.d1 = ReadFloat(); |
| pMatrix.a2 = ReadFloat(); pMatrix.b2 = ReadFloat(); |
| pMatrix.c2 = ReadFloat(); pMatrix.d2 = ReadFloat(); |
| pMatrix.a3 = ReadFloat(); pMatrix.b3 = ReadFloat(); |
| pMatrix.c3 = ReadFloat(); pMatrix.d3 = ReadFloat(); |
| pMatrix.a4 = ReadFloat(); pMatrix.b4 = ReadFloat(); |
| pMatrix.c4 = ReadFloat(); pMatrix.d4 = ReadFloat(); |
| |
| // trailing symbols |
| CheckForSemicolon(); |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectMesh( Mesh* pMesh) |
| { |
| std::string name; |
| readHeadOfDataObject( &name); |
| |
| // read vertex count |
| unsigned int numVertices = ReadInt(); |
| pMesh->mPositions.resize( numVertices); |
| |
| // read vertices |
| for( unsigned int a = 0; a < numVertices; a++) |
| pMesh->mPositions[a] = ReadVector3(); |
| |
| // read position faces |
| unsigned int numPosFaces = ReadInt(); |
| pMesh->mPosFaces.resize( numPosFaces); |
| for( unsigned int a = 0; a < numPosFaces; a++) |
| { |
| // read indices |
| unsigned int numIndices = ReadInt(); |
| Face& face = pMesh->mPosFaces[a]; |
| for (unsigned int b = 0; b < numIndices; b++) { |
| face.mIndices.push_back( ReadInt() ); |
| } |
| TestForSeparator(); |
| } |
| |
| // here, other data objects may follow |
| bool running = true; |
| while ( running ) |
| { |
| std::string objectName = GetNextToken(); |
| |
| if( objectName.size() == 0) |
| ThrowException( "Unexpected end of file while parsing mesh structure"); |
| else |
| if( objectName == "}") |
| break; // mesh finished |
| else |
| if( objectName == "MeshNormals") |
| ParseDataObjectMeshNormals( pMesh); |
| else |
| if( objectName == "MeshTextureCoords") |
| ParseDataObjectMeshTextureCoords( pMesh); |
| else |
| if( objectName == "MeshVertexColors") |
| ParseDataObjectMeshVertexColors( pMesh); |
| else |
| if( objectName == "MeshMaterialList") |
| ParseDataObjectMeshMaterialList( pMesh); |
| else |
| if( objectName == "VertexDuplicationIndices") |
| ParseUnknownDataObject(); // we'll ignore vertex duplication indices |
| else |
| if( objectName == "XSkinMeshHeader") |
| ParseDataObjectSkinMeshHeader( pMesh); |
| else |
| if( objectName == "SkinWeights") |
| ParseDataObjectSkinWeights( pMesh); |
| else |
| { |
| DefaultLogger::get()->warn("Unknown data object in mesh in x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectSkinWeights( Mesh *pMesh) |
| { |
| readHeadOfDataObject(); |
| |
| std::string transformNodeName; |
| GetNextTokenAsString( transformNodeName); |
| |
| pMesh->mBones.push_back( Bone()); |
| Bone& bone = pMesh->mBones.back(); |
| bone.mName = transformNodeName; |
| |
| // read vertex weights |
| unsigned int numWeights = ReadInt(); |
| bone.mWeights.reserve( numWeights); |
| |
| for( unsigned int a = 0; a < numWeights; a++) |
| { |
| BoneWeight weight; |
| weight.mVertex = ReadInt(); |
| bone.mWeights.push_back( weight); |
| } |
| |
| // read vertex weights |
| for( unsigned int a = 0; a < numWeights; a++) |
| bone.mWeights[a].mWeight = ReadFloat(); |
| |
| // read matrix offset |
| bone.mOffsetMatrix.a1 = ReadFloat(); bone.mOffsetMatrix.b1 = ReadFloat(); |
| bone.mOffsetMatrix.c1 = ReadFloat(); bone.mOffsetMatrix.d1 = ReadFloat(); |
| bone.mOffsetMatrix.a2 = ReadFloat(); bone.mOffsetMatrix.b2 = ReadFloat(); |
| bone.mOffsetMatrix.c2 = ReadFloat(); bone.mOffsetMatrix.d2 = ReadFloat(); |
| bone.mOffsetMatrix.a3 = ReadFloat(); bone.mOffsetMatrix.b3 = ReadFloat(); |
| bone.mOffsetMatrix.c3 = ReadFloat(); bone.mOffsetMatrix.d3 = ReadFloat(); |
| bone.mOffsetMatrix.a4 = ReadFloat(); bone.mOffsetMatrix.b4 = ReadFloat(); |
| bone.mOffsetMatrix.c4 = ReadFloat(); bone.mOffsetMatrix.d4 = ReadFloat(); |
| |
| CheckForSemicolon(); |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectSkinMeshHeader( Mesh* /*pMesh*/ ) |
| { |
| readHeadOfDataObject(); |
| |
| /*unsigned int maxSkinWeightsPerVertex =*/ ReadInt(); |
| /*unsigned int maxSkinWeightsPerFace =*/ ReadInt(); |
| /*unsigned int numBonesInMesh = */ReadInt(); |
| |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectMeshNormals( Mesh* pMesh) |
| { |
| readHeadOfDataObject(); |
| |
| // read count |
| unsigned int numNormals = ReadInt(); |
| pMesh->mNormals.resize( numNormals); |
| |
| // read normal vectors |
| for( unsigned int a = 0; a < numNormals; a++) |
| pMesh->mNormals[a] = ReadVector3(); |
| |
| // read normal indices |
| unsigned int numFaces = ReadInt(); |
| if( numFaces != pMesh->mPosFaces.size()) |
| ThrowException( "Normal face count does not match vertex face count."); |
| |
| for( unsigned int a = 0; a < numFaces; a++) |
| { |
| unsigned int numIndices = ReadInt(); |
| pMesh->mNormFaces.push_back( Face()); |
| Face& face = pMesh->mNormFaces.back(); |
| |
| for( unsigned int b = 0; b < numIndices; b++) |
| face.mIndices.push_back( ReadInt()); |
| |
| TestForSeparator(); |
| } |
| |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectMeshTextureCoords( Mesh* pMesh) |
| { |
| readHeadOfDataObject(); |
| if( pMesh->mNumTextures + 1 > AI_MAX_NUMBER_OF_TEXTURECOORDS) |
| ThrowException( "Too many sets of texture coordinates"); |
| |
| std::vector<aiVector2D>& coords = pMesh->mTexCoords[pMesh->mNumTextures++]; |
| |
| unsigned int numCoords = ReadInt(); |
| if( numCoords != pMesh->mPositions.size()) |
| ThrowException( "Texture coord count does not match vertex count"); |
| |
| coords.resize( numCoords); |
| for( unsigned int a = 0; a < numCoords; a++) |
| coords[a] = ReadVector2(); |
| |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectMeshVertexColors( Mesh* pMesh) |
| { |
| readHeadOfDataObject(); |
| if( pMesh->mNumColorSets + 1 > AI_MAX_NUMBER_OF_COLOR_SETS) |
| ThrowException( "Too many colorsets"); |
| std::vector<aiColor4D>& colors = pMesh->mColors[pMesh->mNumColorSets++]; |
| |
| unsigned int numColors = ReadInt(); |
| if( numColors != pMesh->mPositions.size()) |
| ThrowException( "Vertex color count does not match vertex count"); |
| |
| colors.resize( numColors, aiColor4D( 0, 0, 0, 1)); |
| for( unsigned int a = 0; a < numColors; a++) |
| { |
| unsigned int index = ReadInt(); |
| if( index >= pMesh->mPositions.size()) |
| ThrowException( "Vertex color index out of bounds"); |
| |
| colors[index] = ReadRGBA(); |
| // HACK: (thom) Maxon Cinema XPort plugin puts a third separator here, kwxPort puts a comma. |
| // Ignore gracefully. |
| if( !mIsBinaryFormat) |
| { |
| FindNextNoneWhiteSpace(); |
| if( *P == ';' || *P == ',') |
| P++; |
| } |
| } |
| |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectMeshMaterialList( Mesh* pMesh) |
| { |
| readHeadOfDataObject(); |
| |
| // read material count |
| /*unsigned int numMaterials =*/ ReadInt(); |
| // read non triangulated face material index count |
| unsigned int numMatIndices = ReadInt(); |
| |
| // some models have a material index count of 1... to be able to read them we |
| // replicate this single material index on every face |
| if( numMatIndices != pMesh->mPosFaces.size() && numMatIndices != 1) |
| ThrowException( "Per-Face material index count does not match face count."); |
| |
| // read per-face material indices |
| for( unsigned int a = 0; a < numMatIndices; a++) |
| pMesh->mFaceMaterials.push_back( ReadInt()); |
| |
| // in version 03.02, the face indices end with two semicolons. |
| // commented out version check, as version 03.03 exported from blender also has 2 semicolons |
| if( !mIsBinaryFormat) // && MajorVersion == 3 && MinorVersion <= 2) |
| { |
| if(P < End && *P == ';') |
| ++P; |
| } |
| |
| // if there was only a single material index, replicate it on all faces |
| while( pMesh->mFaceMaterials.size() < pMesh->mPosFaces.size()) |
| pMesh->mFaceMaterials.push_back( pMesh->mFaceMaterials.front()); |
| |
| // read following data objects |
| bool running = true; |
| while ( running ) |
| { |
| std::string objectName = GetNextToken(); |
| if( objectName.size() == 0) |
| ThrowException( "Unexpected end of file while parsing mesh material list."); |
| else |
| if( objectName == "}") |
| break; // material list finished |
| else |
| if( objectName == "{") |
| { |
| // template materials |
| std::string matName = GetNextToken(); |
| Material material; |
| material.mIsReference = true; |
| material.mName = matName; |
| pMesh->mMaterials.push_back( material); |
| |
| CheckForClosingBrace(); // skip } |
| } else |
| if( objectName == "Material") |
| { |
| pMesh->mMaterials.push_back( Material()); |
| ParseDataObjectMaterial( &pMesh->mMaterials.back()); |
| } else |
| if( objectName == ";") |
| { |
| // ignore |
| } else |
| { |
| DefaultLogger::get()->warn("Unknown data object in material list in x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectMaterial( Material* pMaterial) |
| { |
| std::string matName; |
| readHeadOfDataObject( &matName); |
| if( matName.empty()) |
| matName = std::string( "material") + to_string( mLineNumber ); |
| pMaterial->mName = matName; |
| pMaterial->mIsReference = false; |
| |
| // read material values |
| pMaterial->mDiffuse = ReadRGBA(); |
| pMaterial->mSpecularExponent = ReadFloat(); |
| pMaterial->mSpecular = ReadRGB(); |
| pMaterial->mEmissive = ReadRGB(); |
| |
| // read other data objects |
| bool running = true; |
| while ( running ) |
| { |
| std::string objectName = GetNextToken(); |
| if( objectName.size() == 0) |
| ThrowException( "Unexpected end of file while parsing mesh material"); |
| else |
| if( objectName == "}") |
| break; // material finished |
| else |
| if( objectName == "TextureFilename" || objectName == "TextureFileName") |
| { |
| // some exporters write "TextureFileName" instead. |
| std::string texname; |
| ParseDataObjectTextureFilename( texname); |
| pMaterial->mTextures.push_back( TexEntry( texname)); |
| } else |
| if( objectName == "NormalmapFilename" || objectName == "NormalmapFileName") |
| { |
| // one exporter writes out the normal map in a separate filename tag |
| std::string texname; |
| ParseDataObjectTextureFilename( texname); |
| pMaterial->mTextures.push_back( TexEntry( texname, true)); |
| } else |
| { |
| DefaultLogger::get()->warn("Unknown data object in material in x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectAnimTicksPerSecond() |
| { |
| readHeadOfDataObject(); |
| mScene->mAnimTicksPerSecond = ReadInt(); |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectAnimationSet() |
| { |
| std::string animName; |
| readHeadOfDataObject( &animName); |
| |
| Animation* anim = new Animation; |
| mScene->mAnims.push_back( anim); |
| anim->mName = animName; |
| |
| bool running = true; |
| while ( running ) |
| { |
| std::string objectName = GetNextToken(); |
| if( objectName.length() == 0) |
| ThrowException( "Unexpected end of file while parsing animation set."); |
| else |
| if( objectName == "}") |
| break; // animation set finished |
| else |
| if( objectName == "Animation") |
| ParseDataObjectAnimation( anim); |
| else |
| { |
| DefaultLogger::get()->warn("Unknown data object in animation set in x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectAnimation( Animation* pAnim) |
| { |
| readHeadOfDataObject(); |
| AnimBone* banim = new AnimBone; |
| pAnim->mAnims.push_back( banim); |
| |
| bool running = true; |
| while( running ) |
| { |
| std::string objectName = GetNextToken(); |
| |
| if( objectName.length() == 0) |
| ThrowException( "Unexpected end of file while parsing animation."); |
| else |
| if( objectName == "}") |
| break; // animation finished |
| else |
| if( objectName == "AnimationKey") |
| ParseDataObjectAnimationKey( banim); |
| else |
| if( objectName == "AnimationOptions") |
| ParseUnknownDataObject(); // not interested |
| else |
| if( objectName == "{") |
| { |
| // read frame name |
| banim->mBoneName = GetNextToken(); |
| CheckForClosingBrace(); |
| } else |
| { |
| DefaultLogger::get()->warn("Unknown data object in animation in x file"); |
| ParseUnknownDataObject(); |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectAnimationKey( AnimBone* pAnimBone) |
| { |
| readHeadOfDataObject(); |
| |
| // read key type |
| unsigned int keyType = ReadInt(); |
| |
| // read number of keys |
| unsigned int numKeys = ReadInt(); |
| |
| for( unsigned int a = 0; a < numKeys; a++) |
| { |
| // read time |
| unsigned int time = ReadInt(); |
| |
| // read keys |
| switch( keyType) |
| { |
| case 0: // rotation quaternion |
| { |
| // read count |
| if( ReadInt() != 4) |
| ThrowException( "Invalid number of arguments for quaternion key in animation"); |
| |
| aiQuatKey key; |
| key.mTime = double( time); |
| key.mValue.w = ReadFloat(); |
| key.mValue.x = ReadFloat(); |
| key.mValue.y = ReadFloat(); |
| key.mValue.z = ReadFloat(); |
| pAnimBone->mRotKeys.push_back( key); |
| |
| CheckForSemicolon(); |
| break; |
| } |
| |
| case 1: // scale vector |
| case 2: // position vector |
| { |
| // read count |
| if( ReadInt() != 3) |
| ThrowException( "Invalid number of arguments for vector key in animation"); |
| |
| aiVectorKey key; |
| key.mTime = double( time); |
| key.mValue = ReadVector3(); |
| |
| if( keyType == 2) |
| pAnimBone->mPosKeys.push_back( key); |
| else |
| pAnimBone->mScaleKeys.push_back( key); |
| |
| break; |
| } |
| |
| case 3: // combined transformation matrix |
| case 4: // denoted both as 3 or as 4 |
| { |
| // read count |
| if( ReadInt() != 16) |
| ThrowException( "Invalid number of arguments for matrix key in animation"); |
| |
| // read matrix |
| MatrixKey key; |
| key.mTime = double( time); |
| key.mMatrix.a1 = ReadFloat(); key.mMatrix.b1 = ReadFloat(); |
| key.mMatrix.c1 = ReadFloat(); key.mMatrix.d1 = ReadFloat(); |
| key.mMatrix.a2 = ReadFloat(); key.mMatrix.b2 = ReadFloat(); |
| key.mMatrix.c2 = ReadFloat(); key.mMatrix.d2 = ReadFloat(); |
| key.mMatrix.a3 = ReadFloat(); key.mMatrix.b3 = ReadFloat(); |
| key.mMatrix.c3 = ReadFloat(); key.mMatrix.d3 = ReadFloat(); |
| key.mMatrix.a4 = ReadFloat(); key.mMatrix.b4 = ReadFloat(); |
| key.mMatrix.c4 = ReadFloat(); key.mMatrix.d4 = ReadFloat(); |
| pAnimBone->mTrafoKeys.push_back( key); |
| |
| CheckForSemicolon(); |
| break; |
| } |
| |
| default: |
| ThrowException( format() << "Unknown key type " << keyType << " in animation." ); |
| break; |
| } // end switch |
| |
| // key separator |
| CheckForSeparator(); |
| } |
| |
| CheckForClosingBrace(); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseDataObjectTextureFilename( std::string& pName) |
| { |
| readHeadOfDataObject(); |
| GetNextTokenAsString( pName); |
| CheckForClosingBrace(); |
| |
| // FIX: some files (e.g. AnimationTest.x) have "" as texture file name |
| if (!pName.length()) |
| { |
| DefaultLogger::get()->warn("Length of texture file name is zero. Skipping this texture."); |
| } |
| |
| // some exporters write double backslash paths out. We simply replace them if we find them |
| while( pName.find( "\\\\") != std::string::npos) |
| pName.replace( pName.find( "\\\\"), 2, "\\"); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ParseUnknownDataObject() |
| { |
| // find opening delimiter |
| bool running = true; |
| while( running ) |
| { |
| std::string t = GetNextToken(); |
| if( t.length() == 0) |
| ThrowException( "Unexpected end of file while parsing unknown segment."); |
| |
| if( t == "{") |
| break; |
| } |
| |
| unsigned int counter = 1; |
| |
| // parse until closing delimiter |
| while( counter > 0) |
| { |
| std::string t = GetNextToken(); |
| |
| if( t.length() == 0) |
| ThrowException( "Unexpected end of file while parsing unknown segment."); |
| |
| if( t == "{") |
| ++counter; |
| else |
| if( t == "}") |
| --counter; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| //! checks for closing curly brace |
| void XFileParser::CheckForClosingBrace() |
| { |
| if( GetNextToken() != "}") |
| ThrowException( "Closing brace expected."); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| //! checks for one following semicolon |
| void XFileParser::CheckForSemicolon() |
| { |
| if( mIsBinaryFormat) |
| return; |
| |
| if( GetNextToken() != ";") |
| ThrowException( "Semicolon expected."); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| //! checks for a separator char, either a ',' or a ';' |
| void XFileParser::CheckForSeparator() |
| { |
| if( mIsBinaryFormat) |
| return; |
| |
| std::string token = GetNextToken(); |
| if( token != "," && token != ";") |
| ThrowException( "Separator character (';' or ',') expected."); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // tests and possibly consumes a separator char, but does nothing if there was no separator |
| void XFileParser::TestForSeparator() |
| { |
| if( mIsBinaryFormat) |
| return; |
| |
| FindNextNoneWhiteSpace(); |
| if( P >= End) |
| return; |
| |
| // test and skip |
| if( *P == ';' || *P == ',') |
| P++; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::readHeadOfDataObject( std::string* poName) |
| { |
| std::string nameOrBrace = GetNextToken(); |
| if( nameOrBrace != "{") |
| { |
| if( poName) |
| *poName = nameOrBrace; |
| |
| if( GetNextToken() != "{") |
| ThrowException( "Opening brace expected."); |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| std::string XFileParser::GetNextToken() |
| { |
| std::string s; |
| |
| // process binary-formatted file |
| if( mIsBinaryFormat) |
| { |
| // in binary mode it will only return NAME and STRING token |
| // and (correctly) skip over other tokens. |
| |
| if( End - P < 2) return s; |
| unsigned int tok = ReadBinWord(); |
| unsigned int len; |
| |
| // standalone tokens |
| switch( tok) |
| { |
| case 1: |
| // name token |
| if( End - P < 4) return s; |
| len = ReadBinDWord(); |
| if( End - P < int(len)) return s; |
| s = std::string(P, len); |
| P += len; |
| return s; |
| case 2: |
| // string token |
| if( End - P < 4) return s; |
| len = ReadBinDWord(); |
| if( End - P < int(len)) return s; |
| s = std::string(P, len); |
| P += (len + 2); |
| return s; |
| case 3: |
| // integer token |
| P += 4; |
| return "<integer>"; |
| case 5: |
| // GUID token |
| P += 16; |
| return "<guid>"; |
| case 6: |
| if( End - P < 4) return s; |
| len = ReadBinDWord(); |
| P += (len * 4); |
| return "<int_list>"; |
| case 7: |
| if( End - P < 4) return s; |
| len = ReadBinDWord(); |
| P += (len * mBinaryFloatSize); |
| return "<flt_list>"; |
| case 0x0a: |
| return "{"; |
| case 0x0b: |
| return "}"; |
| case 0x0c: |
| return "("; |
| case 0x0d: |
| return ")"; |
| case 0x0e: |
| return "["; |
| case 0x0f: |
| return "]"; |
| case 0x10: |
| return "<"; |
| case 0x11: |
| return ">"; |
| case 0x12: |
| return "."; |
| case 0x13: |
| return ","; |
| case 0x14: |
| return ";"; |
| case 0x1f: |
| return "template"; |
| case 0x28: |
| return "WORD"; |
| case 0x29: |
| return "DWORD"; |
| case 0x2a: |
| return "FLOAT"; |
| case 0x2b: |
| return "DOUBLE"; |
| case 0x2c: |
| return "CHAR"; |
| case 0x2d: |
| return "UCHAR"; |
| case 0x2e: |
| return "SWORD"; |
| case 0x2f: |
| return "SDWORD"; |
| case 0x30: |
| return "void"; |
| case 0x31: |
| return "string"; |
| case 0x32: |
| return "unicode"; |
| case 0x33: |
| return "cstring"; |
| case 0x34: |
| return "array"; |
| } |
| } |
| // process text-formatted file |
| else |
| { |
| FindNextNoneWhiteSpace(); |
| if( P >= End) |
| return s; |
| |
| while( (P < End) && !isspace( (unsigned char) *P)) |
| { |
| // either keep token delimiters when already holding a token, or return if first valid char |
| if( *P == ';' || *P == '}' || *P == '{' || *P == ',') |
| { |
| if( !s.size()) |
| s.append( P++, 1); |
| break; // stop for delimiter |
| } |
| s.append( P++, 1); |
| } |
| } |
| return s; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::FindNextNoneWhiteSpace() |
| { |
| if( mIsBinaryFormat) |
| return; |
| |
| bool running = true; |
| while( running ) |
| { |
| while( P < End && isspace( (unsigned char) *P)) |
| { |
| if( *P == '\n') |
| mLineNumber++; |
| ++P; |
| } |
| |
| if( P >= End) |
| return; |
| |
| // check if this is a comment |
| if( (P[0] == '/' && P[1] == '/') || P[0] == '#') |
| ReadUntilEndOfLine(); |
| else |
| break; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::GetNextTokenAsString( std::string& poString) |
| { |
| if( mIsBinaryFormat) |
| { |
| poString = GetNextToken(); |
| return; |
| } |
| |
| FindNextNoneWhiteSpace(); |
| if( P >= End) |
| ThrowException( "Unexpected end of file while parsing string"); |
| |
| if( *P != '"') |
| ThrowException( "Expected quotation mark."); |
| ++P; |
| |
| while( P < End && *P != '"') |
| poString.append( P++, 1); |
| |
| if( P >= End-1) |
| ThrowException( "Unexpected end of file while parsing string"); |
| |
| if( P[1] != ';' || P[0] != '"') |
| ThrowException( "Expected quotation mark and semicolon at the end of a string."); |
| P+=2; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| void XFileParser::ReadUntilEndOfLine() |
| { |
| if( mIsBinaryFormat) |
| return; |
| |
| while( P < End) |
| { |
| if( *P == '\n' || *P == '\r') |
| { |
| ++P; mLineNumber++; |
| return; |
| } |
| |
| ++P; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| unsigned short XFileParser::ReadBinWord() |
| { |
| ai_assert(End - P >= 2); |
| const unsigned char* q = (const unsigned char*) P; |
| unsigned short tmp = q[0] | (q[1] << 8); |
| P += 2; |
| return tmp; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| unsigned int XFileParser::ReadBinDWord() |
| { |
| ai_assert(End - P >= 4); |
| const unsigned char* q = (const unsigned char*) P; |
| unsigned int tmp = q[0] | (q[1] << 8) | (q[2] << 16) | (q[3] << 24); |
| P += 4; |
| return tmp; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| unsigned int XFileParser::ReadInt() |
| { |
| if( mIsBinaryFormat) |
| { |
| if( mBinaryNumCount == 0 && End - P >= 2) |
| { |
| unsigned short tmp = ReadBinWord(); // 0x06 or 0x03 |
| if( tmp == 0x06 && End - P >= 4) // array of ints follows |
| mBinaryNumCount = ReadBinDWord(); |
| else // single int follows |
| mBinaryNumCount = 1; |
| } |
| |
| --mBinaryNumCount; |
| if ( End - P >= 4) { |
| return ReadBinDWord(); |
| } else { |
| P = End; |
| return 0; |
| } |
| } else |
| { |
| FindNextNoneWhiteSpace(); |
| |
| // TODO: consider using strtol10 instead??? |
| |
| // check preceding minus sign |
| bool isNegative = false; |
| if( *P == '-') |
| { |
| isNegative = true; |
| P++; |
| } |
| |
| // at least one digit expected |
| if( !isdigit( *P)) |
| ThrowException( "Number expected."); |
| |
| // read digits |
| unsigned int number = 0; |
| while( P < End) |
| { |
| if( !isdigit( *P)) |
| break; |
| number = number * 10 + (*P - 48); |
| P++; |
| } |
| |
| CheckForSeparator(); |
| return isNegative ? ((unsigned int) -int( number)) : number; |
| } |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| ai_real XFileParser::ReadFloat() |
| { |
| if( mIsBinaryFormat) |
| { |
| if( mBinaryNumCount == 0 && End - P >= 2) |
| { |
| unsigned short tmp = ReadBinWord(); // 0x07 or 0x42 |
| if( tmp == 0x07 && End - P >= 4) // array of floats following |
| mBinaryNumCount = ReadBinDWord(); |
| else // single float following |
| mBinaryNumCount = 1; |
| } |
| |
| --mBinaryNumCount; |
| if( mBinaryFloatSize == 8) |
| { |
| if( End - P >= 8) { |
| ai_real result = (ai_real) (*(double*) P); |
| P += 8; |
| return result; |
| } else { |
| P = End; |
| return 0; |
| } |
| } else |
| { |
| if( End - P >= 4) { |
| ai_real result = *(ai_real*) P; |
| P += 4; |
| return result; |
| } else { |
| P = End; |
| return 0; |
| } |
| } |
| } |
| |
| // text version |
| FindNextNoneWhiteSpace(); |
| // check for various special strings to allow reading files from faulty exporters |
| // I mean you, Blender! |
| // Reading is safe because of the terminating zero |
| if( strncmp( P, "-1.#IND00", 9) == 0 || strncmp( P, "1.#IND00", 8) == 0) |
| { |
| P += 9; |
| CheckForSeparator(); |
| return 0.0; |
| } else |
| if( strncmp( P, "1.#QNAN0", 8) == 0) |
| { |
| P += 8; |
| CheckForSeparator(); |
| return 0.0; |
| } |
| |
| ai_real result = 0.0; |
| P = fast_atoreal_move<ai_real>( P, result); |
| |
| CheckForSeparator(); |
| |
| return result; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| aiVector2D XFileParser::ReadVector2() |
| { |
| aiVector2D vector; |
| vector.x = ReadFloat(); |
| vector.y = ReadFloat(); |
| TestForSeparator(); |
| |
| return vector; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| aiVector3D XFileParser::ReadVector3() |
| { |
| aiVector3D vector; |
| vector.x = ReadFloat(); |
| vector.y = ReadFloat(); |
| vector.z = ReadFloat(); |
| TestForSeparator(); |
| |
| return vector; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| aiColor4D XFileParser::ReadRGBA() |
| { |
| aiColor4D color; |
| color.r = ReadFloat(); |
| color.g = ReadFloat(); |
| color.b = ReadFloat(); |
| color.a = ReadFloat(); |
| TestForSeparator(); |
| |
| return color; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| aiColor3D XFileParser::ReadRGB() |
| { |
| aiColor3D color; |
| color.r = ReadFloat(); |
| color.g = ReadFloat(); |
| color.b = ReadFloat(); |
| TestForSeparator(); |
| |
| return color; |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Throws an exception with a line number and the given text. |
| AI_WONT_RETURN void XFileParser::ThrowException( const std::string& pText) |
| { |
| if( mIsBinaryFormat) |
| throw DeadlyImportError( pText); |
| else |
| throw DeadlyImportError( format() << "Line " << mLineNumber << ": " << pText ); |
| } |
| |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Filters the imported hierarchy for some degenerated cases that some exporters produce. |
| void XFileParser::FilterHierarchy( XFile::Node* pNode) |
| { |
| // if the node has just a single unnamed child containing a mesh, remove |
| // the anonymous node between. The 3DSMax kwXport plugin seems to produce this |
| // mess in some cases |
| if( pNode->mChildren.size() == 1 && pNode->mMeshes.empty() ) |
| { |
| XFile::Node* child = pNode->mChildren.front(); |
| if( child->mName.length() == 0 && child->mMeshes.size() > 0) |
| { |
| // transfer its meshes to us |
| for( unsigned int a = 0; a < child->mMeshes.size(); a++) |
| pNode->mMeshes.push_back( child->mMeshes[a]); |
| child->mMeshes.clear(); |
| |
| // transfer the transform as well |
| pNode->mTrafoMatrix = pNode->mTrafoMatrix * child->mTrafoMatrix; |
| |
| // then kill it |
| delete child; |
| pNode->mChildren.clear(); |
| } |
| } |
| |
| // recurse |
| for( unsigned int a = 0; a < pNode->mChildren.size(); a++) |
| FilterHierarchy( pNode->mChildren[a]); |
| } |
| |
| #endif // !! ASSIMP_BUILD_NO_X_IMPORTER |
