1398 lines
45 KiB
C++
1398 lines
45 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2021, 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 <assimp/ByteSwapper.h>
|
|
#include <assimp/Exceptional.h>
|
|
#include <assimp/StringUtils.h>
|
|
#include <assimp/TinyFormatter.h>
|
|
#include <assimp/fast_atof.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
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Throws an exception with a line number and the given text.
|
|
template<typename... T>
|
|
AI_WONT_RETURN void XFileParser::ThrowException(T&&... args) {
|
|
if (mIsBinaryFormat) {
|
|
throw DeadlyImportError(args...);
|
|
} else {
|
|
throw DeadlyImportError("Line ", mLineNumber, ": ", args...);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Constructor. Creates a data structure out of the XFile given in the memory block.
|
|
XFileParser::XFileParser(const std::vector<char> &pBuffer) :
|
|
mMajorVersion(0), mMinorVersion(0), mIsBinaryFormat(false), mBinaryNumCount(0), mP(nullptr), mEnd(nullptr), mLineNumber(0), mScene(nullptr) {
|
|
// vector to store uncompressed file for INFLATE'd X files
|
|
std::vector<char> uncompressed;
|
|
|
|
// set up memory pointers
|
|
mP = &pBuffer.front();
|
|
mEnd = mP + pBuffer.size() - 1;
|
|
|
|
// check header
|
|
if (0 != strncmp(mP, "xof ", 4)) {
|
|
throw DeadlyImportError("Header mismatch, file is not an XFile.");
|
|
}
|
|
|
|
// read version. It comes in a four byte format such as "0302"
|
|
mMajorVersion = (unsigned int)(mP[4] - 48) * 10 + (unsigned int)(mP[5] - 48);
|
|
mMinorVersion = (unsigned int)(mP[6] - 48) * 10 + (unsigned int)(mP[7] - 48);
|
|
|
|
bool compressed = false;
|
|
|
|
// txt - pure ASCII text format
|
|
if (strncmp(mP + 8, "txt ", 4) == 0)
|
|
mIsBinaryFormat = false;
|
|
|
|
// bin - Binary format
|
|
else if (strncmp(mP + 8, "bin ", 4) == 0)
|
|
mIsBinaryFormat = true;
|
|
|
|
// tzip - Inflate compressed text format
|
|
else if (strncmp(mP + 8, "tzip", 4) == 0) {
|
|
mIsBinaryFormat = false;
|
|
compressed = true;
|
|
}
|
|
// bzip - Inflate compressed binary format
|
|
else if (strncmp(mP + 8, "bzip", 4) == 0) {
|
|
mIsBinaryFormat = true;
|
|
compressed = true;
|
|
} else
|
|
ThrowException("Unsupported xfile format '", mP[8], mP[9], mP[10], mP[11], "'");
|
|
|
|
// float size
|
|
mBinaryFloatSize = (unsigned int)(mP[12] - 48) * 1000 + (unsigned int)(mP[13] - 48) * 100 + (unsigned int)(mP[14] - 48) * 10 + (unsigned int)(mP[15] - 48);
|
|
|
|
if (mBinaryFloatSize != 32 && mBinaryFloatSize != 64)
|
|
ThrowException("Unknown float size ", mBinaryFloatSize, " specified in xfile header.");
|
|
|
|
// The x format specifies size in bits, but we work in bytes
|
|
mBinaryFloatSize /= 8;
|
|
|
|
mP += 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 = nullptr;
|
|
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?)
|
|
mP += 6;
|
|
|
|
// First find out how much storage we'll need. Count sections.
|
|
const char *P1 = mP;
|
|
unsigned int est_out = 0;
|
|
|
|
while (P1 + 3 < mEnd) {
|
|
// 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 (mP + 3 < mEnd) {
|
|
uint16_t ofs = *((uint16_t *)mP);
|
|
AI_SWAP2(ofs);
|
|
mP += 4;
|
|
|
|
if (mP + ofs > mEnd + 2) {
|
|
throw DeadlyImportError("X: Unexpected EOF in compressed chunk");
|
|
}
|
|
|
|
// push data to the stream
|
|
stream.next_in = (Bytef *)mP;
|
|
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;
|
|
mP += ofs;
|
|
}
|
|
|
|
// terminate zlib
|
|
::inflateEnd(&stream);
|
|
|
|
// ok, update pointers to point to the uncompressed file data
|
|
mP = &uncompressed[0];
|
|
mEnd = out;
|
|
|
|
// FIXME: we don't need the compressed data anymore, could release
|
|
// it already for better memory usage. Consider breaking const-co.
|
|
ASSIMP_LOG_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(nullptr);
|
|
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?
|
|
ASSIMP_LOG_WARN("} found in dataObject");
|
|
} else {
|
|
// unknown format
|
|
ASSIMP_LOG_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 != nullptr) {
|
|
// place a dummy root if not there
|
|
if (mScene->mRootNode->mName != "$dummy_root") {
|
|
Node *exroot = mScene->mRootNode;
|
|
mScene->mRootNode = new Node(nullptr);
|
|
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 {
|
|
ASSIMP_LOG_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) {
|
|
const int idx(ReadInt());
|
|
if (static_cast<unsigned int>(idx) <= numVertices) {
|
|
face.mIndices.push_back(idx);
|
|
}
|
|
}
|
|
TestForSeparator();
|
|
}
|
|
|
|
// here, other data objects may follow
|
|
bool running = true;
|
|
while (running) {
|
|
std::string objectName = GetNextToken();
|
|
|
|
if (objectName.empty())
|
|
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 {
|
|
ASSIMP_LOG_WARN("Unknown data object in mesh in x file");
|
|
ParseUnknownDataObject();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void XFileParser::ParseDataObjectSkinWeights(Mesh *pMesh) {
|
|
if (nullptr == pMesh) {
|
|
return;
|
|
}
|
|
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.");
|
|
}
|
|
|
|
// do not crah when no face definitions are there
|
|
if (numFaces > 0) {
|
|
// normal face creation
|
|
pMesh->mNormFaces.resize(numFaces);
|
|
for (unsigned int a = 0; a < numFaces; ++a) {
|
|
unsigned int numIndices = ReadInt();
|
|
pMesh->mNormFaces[a] = Face();
|
|
Face &face = pMesh->mNormFaces[a];
|
|
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 (*mP == ';' || *mP == ',')
|
|
mP++;
|
|
}
|
|
}
|
|
|
|
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 (mP < mEnd && *mP == ';')
|
|
++mP;
|
|
}
|
|
|
|
// 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 {
|
|
ASSIMP_LOG_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") + ai_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 {
|
|
ASSIMP_LOG_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 {
|
|
ASSIMP_LOG_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 {
|
|
ASSIMP_LOG_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("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()) {
|
|
ASSIMP_LOG_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 (mP >= mEnd)
|
|
return;
|
|
|
|
// test and skip
|
|
if (*mP == ';' || *mP == ',')
|
|
mP++;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void XFileParser::readHeadOfDataObject(std::string *poName) {
|
|
std::string nameOrBrace = GetNextToken();
|
|
if (nameOrBrace != "{") {
|
|
if (poName)
|
|
*poName = nameOrBrace;
|
|
|
|
if (GetNextToken() != "{") {
|
|
delete mScene;
|
|
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 (mEnd - mP < 2) {
|
|
return s;
|
|
}
|
|
unsigned int tok = ReadBinWord();
|
|
unsigned int len;
|
|
|
|
// standalone tokens
|
|
switch (tok) {
|
|
case 1: {
|
|
// name token
|
|
if (mEnd - mP < 4) {
|
|
return s;
|
|
}
|
|
len = ReadBinDWord();
|
|
const int bounds = int(mEnd - mP);
|
|
const int iLen = int(len);
|
|
if (iLen < 0) {
|
|
return s;
|
|
}
|
|
if (bounds < iLen) {
|
|
return s;
|
|
}
|
|
s = std::string(mP, len);
|
|
mP += len;
|
|
}
|
|
return s;
|
|
|
|
case 2:
|
|
// string token
|
|
if (mEnd - mP < 4) return s;
|
|
len = ReadBinDWord();
|
|
if (mEnd - mP < int(len)) return s;
|
|
s = std::string(mP, len);
|
|
mP += (len + 2);
|
|
return s;
|
|
case 3:
|
|
// integer token
|
|
mP += 4;
|
|
return "<integer>";
|
|
case 5:
|
|
// GUID token
|
|
mP += 16;
|
|
return "<guid>";
|
|
case 6:
|
|
if (mEnd - mP < 4) return s;
|
|
len = ReadBinDWord();
|
|
mP += (len * 4);
|
|
return "<int_list>";
|
|
case 7:
|
|
if (mEnd - mP < 4) return s;
|
|
len = ReadBinDWord();
|
|
mP += (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 (mP >= mEnd)
|
|
return s;
|
|
|
|
while ((mP < mEnd) && !isspace((unsigned char)*mP)) {
|
|
// either keep token delimiters when already holding a token, or return if first valid char
|
|
if (*mP == ';' || *mP == '}' || *mP == '{' || *mP == ',') {
|
|
if (!s.size())
|
|
s.append(mP++, 1);
|
|
break; // stop for delimiter
|
|
}
|
|
s.append(mP++, 1);
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void XFileParser::FindNextNoneWhiteSpace() {
|
|
if (mIsBinaryFormat)
|
|
return;
|
|
|
|
bool running = true;
|
|
while (running) {
|
|
while (mP < mEnd && isspace((unsigned char)*mP)) {
|
|
if (*mP == '\n')
|
|
mLineNumber++;
|
|
++mP;
|
|
}
|
|
|
|
if (mP >= mEnd)
|
|
return;
|
|
|
|
// check if this is a comment
|
|
if ((mP[0] == '/' && mP[1] == '/') || mP[0] == '#')
|
|
ReadUntilEndOfLine();
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void XFileParser::GetNextTokenAsString(std::string &poString) {
|
|
if (mIsBinaryFormat) {
|
|
poString = GetNextToken();
|
|
return;
|
|
}
|
|
|
|
FindNextNoneWhiteSpace();
|
|
if (mP >= mEnd) {
|
|
delete mScene;
|
|
ThrowException("Unexpected end of file while parsing string");
|
|
}
|
|
|
|
if (*mP != '"') {
|
|
delete mScene;
|
|
ThrowException("Expected quotation mark.");
|
|
}
|
|
++mP;
|
|
|
|
while (mP < mEnd && *mP != '"')
|
|
poString.append(mP++, 1);
|
|
|
|
if (mP >= mEnd - 1) {
|
|
delete mScene;
|
|
ThrowException("Unexpected end of file while parsing string");
|
|
}
|
|
|
|
if (mP[1] != ';' || mP[0] != '"') {
|
|
delete mScene;
|
|
ThrowException("Expected quotation mark and semicolon at the end of a string.");
|
|
}
|
|
mP += 2;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void XFileParser::ReadUntilEndOfLine() {
|
|
if (mIsBinaryFormat)
|
|
return;
|
|
|
|
while (mP < mEnd) {
|
|
if (*mP == '\n' || *mP == '\r') {
|
|
++mP;
|
|
mLineNumber++;
|
|
return;
|
|
}
|
|
|
|
++mP;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
unsigned short XFileParser::ReadBinWord() {
|
|
ai_assert(mEnd - mP >= 2);
|
|
const unsigned char *q = (const unsigned char *)mP;
|
|
unsigned short tmp = q[0] | (q[1] << 8);
|
|
mP += 2;
|
|
return tmp;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
unsigned int XFileParser::ReadBinDWord() {
|
|
ai_assert(mEnd - mP >= 4);
|
|
|
|
const unsigned char *q = (const unsigned char *)mP;
|
|
unsigned int tmp = q[0] | (q[1] << 8) | (q[2] << 16) | (q[3] << 24);
|
|
mP += 4;
|
|
return tmp;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
unsigned int XFileParser::ReadInt() {
|
|
if (mIsBinaryFormat) {
|
|
if (mBinaryNumCount == 0 && mEnd - mP >= 2) {
|
|
unsigned short tmp = ReadBinWord(); // 0x06 or 0x03
|
|
if (tmp == 0x06 && mEnd - mP >= 4) // array of ints follows
|
|
mBinaryNumCount = ReadBinDWord();
|
|
else // single int follows
|
|
mBinaryNumCount = 1;
|
|
}
|
|
|
|
--mBinaryNumCount;
|
|
const size_t len(mEnd - mP);
|
|
if (len >= 4) {
|
|
return ReadBinDWord();
|
|
} else {
|
|
mP = mEnd;
|
|
return 0;
|
|
}
|
|
} else {
|
|
FindNextNoneWhiteSpace();
|
|
|
|
// TODO: consider using strtol10 instead???
|
|
|
|
// check preceding minus sign
|
|
bool isNegative = false;
|
|
if (*mP == '-') {
|
|
isNegative = true;
|
|
mP++;
|
|
}
|
|
|
|
// at least one digit expected
|
|
if (!isdigit(*mP))
|
|
ThrowException("Number expected.");
|
|
|
|
// read digits
|
|
unsigned int number = 0;
|
|
while (mP < mEnd) {
|
|
if (!isdigit(*mP))
|
|
break;
|
|
number = number * 10 + (*mP - 48);
|
|
mP++;
|
|
}
|
|
|
|
CheckForSeparator();
|
|
|
|
return isNegative ? ((unsigned int)-int(number)) : number;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
ai_real XFileParser::ReadFloat() {
|
|
if (mIsBinaryFormat) {
|
|
if (mBinaryNumCount == 0 && mEnd - mP >= 2) {
|
|
unsigned short tmp = ReadBinWord(); // 0x07 or 0x42
|
|
if (tmp == 0x07 && mEnd - mP >= 4) // array of floats following
|
|
mBinaryNumCount = ReadBinDWord();
|
|
else // single float following
|
|
mBinaryNumCount = 1;
|
|
}
|
|
|
|
--mBinaryNumCount;
|
|
if (mBinaryFloatSize == 8) {
|
|
if (mEnd - mP >= 8) {
|
|
double res;
|
|
::memcpy(&res, mP, 8);
|
|
mP += 8;
|
|
const ai_real result(static_cast<ai_real>(res));
|
|
return result;
|
|
} else {
|
|
mP = mEnd;
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (mEnd - mP >= 4) {
|
|
ai_real result;
|
|
::memcpy(&result, mP, 4);
|
|
mP += 4;
|
|
return result;
|
|
} else {
|
|
mP = mEnd;
|
|
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(mP, "-1.#IND00", 9) == 0 || strncmp(mP, "1.#IND00", 8) == 0) {
|
|
mP += 9;
|
|
CheckForSeparator();
|
|
return 0.0;
|
|
} else if (strncmp(mP, "1.#QNAN0", 8) == 0) {
|
|
mP += 8;
|
|
CheckForSeparator();
|
|
return 0.0;
|
|
}
|
|
|
|
ai_real result = 0.0;
|
|
mP = fast_atoreal_move<ai_real>(mP, 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;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// 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
|