740 lines
17 KiB
C++
740 lines
17 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2012, 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 FBXDocument.h
|
|
* @brief FBX DOM
|
|
*/
|
|
#ifndef INCLUDED_AI_FBX_DOCUMENT_H
|
|
#define INCLUDED_AI_FBX_DOCUMENT_H
|
|
|
|
#include <vector>
|
|
#include <map>
|
|
#include <string>
|
|
|
|
namespace Assimp {
|
|
namespace FBX {
|
|
|
|
class Parser;
|
|
class Object;
|
|
struct ImportSettings;
|
|
|
|
class PropertyTable;
|
|
class Document;
|
|
class Material;
|
|
class Geometry;
|
|
|
|
|
|
/** Represents a delay-parsed FBX objects. Many objects in the scene
|
|
* are not needed by assimp, so it makes no sense to parse them
|
|
* upfront. */
|
|
class LazyObject
|
|
{
|
|
public:
|
|
|
|
LazyObject(uint64_t id, const Element& element, const Document& doc);
|
|
~LazyObject();
|
|
|
|
public:
|
|
|
|
const Object* Get(bool dieOnError = false);
|
|
|
|
template <typename T>
|
|
const T* Get(bool dieOnError = false) {
|
|
const Object* const ob = Get(dieOnError);
|
|
return ob ? dynamic_cast<const T*>(ob) : NULL;
|
|
}
|
|
|
|
uint64_t ID() const {
|
|
return id;
|
|
}
|
|
|
|
bool IsBeingConstructed() const {
|
|
return (flags & BEING_CONSTRUCTED) != 0;
|
|
}
|
|
|
|
bool FailedToConstruct() const {
|
|
return (flags & FAILED_TO_CONSTRUCT) != 0;
|
|
}
|
|
|
|
const Element& GetElement() const {
|
|
return element;
|
|
}
|
|
|
|
const Document& GetDocument() const {
|
|
return doc;
|
|
}
|
|
|
|
private:
|
|
|
|
const Document& doc;
|
|
const Element& element;
|
|
boost::scoped_ptr<const Object> object;
|
|
|
|
const uint64_t id;
|
|
|
|
enum Flags {
|
|
BEING_CONSTRUCTED = 0x1,
|
|
FAILED_TO_CONSTRUCT = 0x2
|
|
};
|
|
|
|
unsigned int flags;
|
|
};
|
|
|
|
|
|
|
|
/** Base class for in-memory (DOM) representations of FBX objects */
|
|
class Object
|
|
{
|
|
public:
|
|
|
|
Object(uint64_t id, const Element& element, const std::string& name);
|
|
virtual ~Object();
|
|
|
|
public:
|
|
|
|
const Element& SourceElement() const {
|
|
return element;
|
|
}
|
|
|
|
const std::string& Name() const {
|
|
return name;
|
|
}
|
|
|
|
uint64_t ID() const {
|
|
return id;
|
|
}
|
|
|
|
protected:
|
|
const Element& element;
|
|
const std::string name;
|
|
const uint64_t id;
|
|
};
|
|
|
|
|
|
/** DOM base class for FBX models (even though its semantics are more "node" than "model" */
|
|
class Model : public Object
|
|
{
|
|
public:
|
|
|
|
Model(uint64_t id, const Element& element, const Document& doc, const std::string& name);
|
|
~Model();
|
|
|
|
public:
|
|
|
|
const std::string& Shading() const {
|
|
return shading;
|
|
}
|
|
|
|
const std::string& Culling() const {
|
|
return culling;
|
|
}
|
|
|
|
const PropertyTable& Props() const {
|
|
ai_assert(props.get());
|
|
return *props.get();
|
|
}
|
|
|
|
/** Get material links */
|
|
const std::vector<const Material*>& GetMaterials() const {
|
|
return materials;
|
|
}
|
|
|
|
|
|
/** Get geometry links */
|
|
const std::vector<const Geometry*>& GetGeometry() const {
|
|
return geometry;
|
|
}
|
|
|
|
private:
|
|
|
|
void ResolveLinks(const Element& element, const Document& doc);
|
|
|
|
private:
|
|
|
|
std::vector<const Material*> materials;
|
|
std::vector<const Geometry*> geometry;
|
|
|
|
std::string shading;
|
|
std::string culling;
|
|
boost::shared_ptr<const PropertyTable> props;
|
|
};
|
|
|
|
|
|
|
|
/** DOM class for generic FBX textures */
|
|
class Texture : public Object
|
|
{
|
|
public:
|
|
|
|
Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name);
|
|
~Texture();
|
|
|
|
public:
|
|
|
|
const std::string& Type() const {
|
|
return type;
|
|
}
|
|
|
|
const std::string& FileName() const {
|
|
return fileName;
|
|
}
|
|
|
|
const std::string& RelativeFilename() const {
|
|
return relativeFileName;
|
|
}
|
|
|
|
const std::string& AlphaSource() const {
|
|
return alphaSource;
|
|
}
|
|
|
|
const aiVector2D& UVTranslation() const {
|
|
return uvTrans;
|
|
}
|
|
|
|
const aiVector2D& UVScaling() const {
|
|
return uvScaling;
|
|
}
|
|
|
|
const PropertyTable& Props() const {
|
|
ai_assert(props.get());
|
|
return *props.get();
|
|
}
|
|
|
|
// return a 4-tuple
|
|
const unsigned int* Crop() const {
|
|
return crop;
|
|
}
|
|
|
|
private:
|
|
|
|
aiVector2D uvTrans;
|
|
aiVector2D uvScaling;
|
|
|
|
std::string type;
|
|
std::string relativeFileName;
|
|
std::string fileName;
|
|
std::string alphaSource;
|
|
boost::shared_ptr<const PropertyTable> props;
|
|
|
|
unsigned int crop[4];
|
|
};
|
|
|
|
|
|
typedef std::fbx_unordered_map<std::string, const Texture*> TextureMap;
|
|
|
|
|
|
/** DOM class for generic FBX materials */
|
|
class Material : public Object
|
|
{
|
|
public:
|
|
|
|
Material(uint64_t id, const Element& element, const Document& doc, const std::string& name);
|
|
~Material();
|
|
|
|
public:
|
|
|
|
const std::string& GetShadingModel() const {
|
|
return shading;
|
|
}
|
|
|
|
bool IsMultilayer() const {
|
|
return multilayer;
|
|
}
|
|
|
|
const PropertyTable& Props() const {
|
|
ai_assert(props.get());
|
|
return *props.get();
|
|
}
|
|
|
|
const TextureMap& Textures() const {
|
|
return textures;
|
|
}
|
|
|
|
private:
|
|
|
|
std::string shading;
|
|
bool multilayer;
|
|
boost::shared_ptr<const PropertyTable> props;
|
|
|
|
TextureMap textures;
|
|
};
|
|
|
|
|
|
/** DOM base class for all kinds of FBX geometry */
|
|
class Geometry : public Object
|
|
{
|
|
public:
|
|
|
|
Geometry(uint64_t id, const Element& element, const std::string& name);
|
|
~Geometry();
|
|
};
|
|
|
|
|
|
/** DOM class for FBX geometry of type "Mesh"*/
|
|
class MeshGeometry : public Geometry
|
|
{
|
|
|
|
public:
|
|
|
|
MeshGeometry(uint64_t id, const Element& element, const std::string& name, const Document& doc);
|
|
~MeshGeometry();
|
|
|
|
public:
|
|
|
|
/** Get a list of all vertex points, non-unique*/
|
|
const std::vector<aiVector3D>& GetVertices() const {
|
|
return vertices;
|
|
}
|
|
|
|
/** Get a list of all vertex normals or an empty array if
|
|
* no normals are specified. */
|
|
const std::vector<aiVector3D>& GetNormals() const {
|
|
return normals;
|
|
}
|
|
|
|
/** Get a list of all vertex tangents or an empty array
|
|
* if no tangents are specified */
|
|
const std::vector<aiVector3D>& GetTangents() const {
|
|
return tangents;
|
|
}
|
|
|
|
/** Get a list of all vertex binormals or an empty array
|
|
* if no binormals are specified */
|
|
const std::vector<aiVector3D>& GetBinormals() const {
|
|
return binormals;
|
|
}
|
|
|
|
/** Return list of faces - each entry denotes a face and specifies
|
|
* how many vertices it has. Vertices are taken from the
|
|
* vertex data arrays in sequential order. */
|
|
const std::vector<unsigned int>& GetFaceIndexCounts() const {
|
|
return faces;
|
|
}
|
|
|
|
/** Get a UV coordinate slot, returns an empty array if
|
|
* the requested slot does not exist. */
|
|
const std::vector<aiVector2D>& GetTextureCoords(unsigned int index) const {
|
|
static const std::vector<aiVector2D> empty;
|
|
return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? empty : uvs[index];
|
|
}
|
|
|
|
|
|
/** Get a UV coordinate slot, returns an empty array if
|
|
* the requested slot does not exist. */
|
|
std::string GetTextureCoordChannelName(unsigned int index) const {
|
|
return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? "" : uvNames[index];
|
|
}
|
|
|
|
/** Get a vertex color coordinate slot, returns an empty array if
|
|
* the requested slot does not exist. */
|
|
const std::vector<aiColor4D>& GetVertexColors(unsigned int index) const {
|
|
static const std::vector<aiColor4D> empty;
|
|
return index >= AI_MAX_NUMBER_OF_COLOR_SETS ? empty : colors[index];
|
|
}
|
|
|
|
|
|
/** Get per-face-vertex material assignments */
|
|
const std::vector<unsigned int>& GetMaterialIndices() const {
|
|
return materials;
|
|
}
|
|
|
|
public:
|
|
|
|
private:
|
|
|
|
void ReadLayer(const Scope& layer);
|
|
void ReadLayerElement(const Scope& layerElement);
|
|
void ReadVertexData(const std::string& type, int index, const Scope& source);
|
|
|
|
void ReadVertexDataUV(std::vector<aiVector2D>& uv_out, const Scope& source,
|
|
const std::string& MappingInformationType,
|
|
const std::string& ReferenceInformationType);
|
|
|
|
void ReadVertexDataNormals(std::vector<aiVector3D>& normals_out, const Scope& source,
|
|
const std::string& MappingInformationType,
|
|
const std::string& ReferenceInformationType);
|
|
|
|
void ReadVertexDataColors(std::vector<aiColor4D>& colors_out, const Scope& source,
|
|
const std::string& MappingInformationType,
|
|
const std::string& ReferenceInformationType);
|
|
|
|
void ReadVertexDataTangents(std::vector<aiVector3D>& tangents_out, const Scope& source,
|
|
const std::string& MappingInformationType,
|
|
const std::string& ReferenceInformationType);
|
|
|
|
void ReadVertexDataBinormals(std::vector<aiVector3D>& binormals_out, const Scope& source,
|
|
const std::string& MappingInformationType,
|
|
const std::string& ReferenceInformationType);
|
|
|
|
void ReadVertexDataMaterials(std::vector<unsigned int>& materials_out, const Scope& source,
|
|
const std::string& MappingInformationType,
|
|
const std::string& ReferenceInformationType);
|
|
|
|
private:
|
|
|
|
// cached data arrays
|
|
std::vector<unsigned int> materials;
|
|
std::vector<aiVector3D> vertices;
|
|
std::vector<unsigned int> faces;
|
|
std::vector<aiVector3D> tangents;
|
|
std::vector<aiVector3D> binormals;
|
|
std::vector<aiVector3D> normals;
|
|
|
|
std::string uvNames[AI_MAX_NUMBER_OF_TEXTURECOORDS];
|
|
std::vector<aiVector2D> uvs[AI_MAX_NUMBER_OF_TEXTURECOORDS];
|
|
std::vector<aiColor4D> colors[AI_MAX_NUMBER_OF_COLOR_SETS];
|
|
|
|
std::vector<unsigned int> mapping_counts;
|
|
std::vector<unsigned int> mapping_offsets;
|
|
std::vector<unsigned int> mappings;
|
|
};
|
|
|
|
typedef std::vector<uint64_t> KeyTimeList;
|
|
typedef std::vector<float> KeyValueList;
|
|
|
|
/** Represents a FBX animation curve (i.e. a 1-dimensional set of keyframes and values therefor) */
|
|
class AnimationCurve : public Object
|
|
{
|
|
public:
|
|
|
|
AnimationCurve(uint64_t id, const Element& element, const std::string& name, const Document& doc);
|
|
~AnimationCurve();
|
|
|
|
public:
|
|
|
|
/** get list of keyframe positions (time).
|
|
* Invariant: |GetKeys()| > 0 */
|
|
const KeyTimeList& GetKeys() const {
|
|
return keys;
|
|
}
|
|
|
|
|
|
/** get list of keyframe values.
|
|
* Invariant: |GetKeys()| == |GetValues()| && |GetKeys()| > 0*/
|
|
const KeyValueList& GetValues() const {
|
|
return values;
|
|
}
|
|
|
|
|
|
const std::vector<float>& GetAttributes() const {
|
|
return attributes;
|
|
}
|
|
|
|
const std::vector<unsigned int>& GetFlags() const {
|
|
return flags;
|
|
}
|
|
|
|
private:
|
|
|
|
KeyTimeList keys;
|
|
KeyValueList values;
|
|
std::vector<float> attributes;
|
|
std::vector<unsigned int> flags;
|
|
};
|
|
|
|
// property-name -> animation curve
|
|
typedef std::map<std::string, const AnimationCurve*> AnimationCurveMap;
|
|
|
|
|
|
/** Represents a FBX animation curve (i.e. a mapping from single animation curves to nodes) */
|
|
class AnimationCurveNode : public Object
|
|
{
|
|
public:
|
|
|
|
AnimationCurveNode(uint64_t id, const Element& element, const std::string& name, const Document& doc);
|
|
~AnimationCurveNode();
|
|
|
|
public:
|
|
|
|
const PropertyTable& Props() const {
|
|
ai_assert(props.get());
|
|
return *props.get();
|
|
}
|
|
|
|
|
|
const AnimationCurveMap Curves() const {
|
|
return curves;
|
|
}
|
|
|
|
/** Model instance the curve is assigned to, this is always non-NULL */
|
|
const Model* TargetNode() const {
|
|
return target;
|
|
}
|
|
|
|
/** Property of TargetNode() that is being animated*/
|
|
const std::string& TargetProperty() const {
|
|
return prop;
|
|
}
|
|
|
|
private:
|
|
|
|
const Model* target;
|
|
boost::shared_ptr<const PropertyTable> props;
|
|
AnimationCurveMap curves;
|
|
|
|
std::string prop;
|
|
};
|
|
|
|
typedef std::vector<const AnimationCurveNode*> AnimationCurveNodeList;
|
|
|
|
|
|
/** Represents a FBX animation layer (i.e. a list of node animations) */
|
|
class AnimationLayer : public Object
|
|
{
|
|
public:
|
|
|
|
AnimationLayer(uint64_t id, const Element& element, const std::string& name, const Document& doc);
|
|
~AnimationLayer();
|
|
|
|
public:
|
|
|
|
const PropertyTable& Props() const {
|
|
ai_assert(props.get());
|
|
return *props.get();
|
|
}
|
|
|
|
const AnimationCurveNodeList& Nodes() const {
|
|
return nodes;
|
|
}
|
|
|
|
private:
|
|
|
|
boost::shared_ptr<const PropertyTable> props;
|
|
AnimationCurveNodeList nodes;
|
|
};
|
|
|
|
|
|
typedef std::vector<const AnimationLayer*> AnimationLayerList;
|
|
|
|
|
|
/** Represents a FBX animation stack (i.e. a list of animation layers) */
|
|
class AnimationStack : public Object
|
|
{
|
|
public:
|
|
|
|
AnimationStack(uint64_t id, const Element& element, const std::string& name, const Document& doc);
|
|
~AnimationStack();
|
|
|
|
public:
|
|
|
|
const PropertyTable& Props() const {
|
|
ai_assert(props.get());
|
|
return *props.get();
|
|
}
|
|
|
|
|
|
const AnimationLayerList& Layers() const {
|
|
return layers;
|
|
}
|
|
|
|
private:
|
|
|
|
boost::shared_ptr<const PropertyTable> props;
|
|
AnimationLayerList layers;
|
|
};
|
|
|
|
|
|
|
|
|
|
/** Represents a link between two FBX objects. */
|
|
class Connection
|
|
{
|
|
public:
|
|
|
|
Connection(uint64_t insertionOrder, uint64_t src, uint64_t dest, const std::string& prop, const Document& doc);
|
|
~Connection();
|
|
|
|
// note: a connection ensures that the source and dest objects exist, but
|
|
// not that they have DOM representations, so the return value of one of
|
|
// these functions can still be NULL.
|
|
const Object* SourceObject() const;
|
|
const Object* DestinationObject() const;
|
|
|
|
// these, however, are always guaranteed to be valid
|
|
LazyObject& LazySourceObject() const;
|
|
LazyObject& LazyDestinationObject() const;
|
|
|
|
|
|
/** return the name of the property the connection is attached to.
|
|
* this is an empty string for object to object (OO) connections. */
|
|
const std::string& PropertyName() const {
|
|
return prop;
|
|
}
|
|
|
|
uint64_t InsertionOrder() const {
|
|
return insertionOrder;
|
|
}
|
|
|
|
int CompareTo(const Connection* c) const {
|
|
// note: can't subtract because this would overflow uint64_t
|
|
if(InsertionOrder() > c->InsertionOrder()) {
|
|
return 1;
|
|
}
|
|
else if(InsertionOrder() < c->InsertionOrder()) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool Compare(const Connection* c) const {
|
|
return InsertionOrder() < c->InsertionOrder();
|
|
}
|
|
|
|
public:
|
|
|
|
uint64_t insertionOrder;
|
|
const std::string prop;
|
|
|
|
uint64_t src, dest;
|
|
const Document& doc;
|
|
};
|
|
|
|
|
|
// XXX again, unique_ptr would be useful. shared_ptr is too
|
|
// bloated since the objects have a well-defined single owner
|
|
// during their entire lifetime (Document). FBX files have
|
|
// up to many thousands of objects (most of which we never use),
|
|
// so the memory overhead for them should be kept at a minimum.
|
|
typedef std::map<uint64_t, LazyObject*> ObjectMap;
|
|
typedef std::fbx_unordered_map<std::string, boost::shared_ptr<const PropertyTable> > PropertyTemplateMap;
|
|
|
|
|
|
typedef std::multimap<uint64_t, const Connection*> ConnectionMap;
|
|
|
|
|
|
/** DOM root for a FBX file */
|
|
class Document
|
|
{
|
|
public:
|
|
|
|
Document(const Parser& parser, const ImportSettings& settings);
|
|
~Document();
|
|
|
|
public:
|
|
|
|
LazyObject* GetObject(uint64_t id) const;
|
|
|
|
|
|
unsigned int FBXVersion() const {
|
|
return fbxVersion;
|
|
}
|
|
|
|
const std::string& Creator() const {
|
|
return creator;
|
|
}
|
|
|
|
// elements (in this order): Uear, Month, Day, Hour, Second, Millisecond
|
|
const unsigned int* CreationTimeStamp() const {
|
|
return creationTimeStamp;
|
|
}
|
|
|
|
const PropertyTemplateMap& Templates() const {
|
|
return templates;
|
|
}
|
|
|
|
const ObjectMap& Objects() const {
|
|
return objects;
|
|
}
|
|
|
|
const ImportSettings& Settings() const {
|
|
return settings;
|
|
}
|
|
|
|
const ConnectionMap& ConnectionsBySource() const {
|
|
return src_connections;
|
|
}
|
|
|
|
const ConnectionMap& ConnectionsByDestination() const {
|
|
return dest_connections;
|
|
}
|
|
|
|
// note: the implicit rule in all DOM classes is to always resolve
|
|
// from destination to source (since the FBX object hierarchy is,
|
|
// with very few exceptions, a DAG, this avoids cycles). In all
|
|
// cases that may involve back-facing edges in the object graph,
|
|
// use LazyObject::IsBeingConstructed() to check.
|
|
|
|
std::vector<const Connection*> GetConnectionsBySourceSequenced(uint64_t source) const;
|
|
std::vector<const Connection*> GetConnectionsByDestinationSequenced(uint64_t dest) const;
|
|
|
|
std::vector<const Connection*> GetConnectionsBySourceSequenced(uint64_t source, const char* classname) const;
|
|
std::vector<const Connection*> GetConnectionsByDestinationSequenced(uint64_t dest, const char* classname) const;
|
|
|
|
std::vector<const Connection*> GetConnectionsBySourceSequenced(uint64_t source, const char* const* classnames, size_t count) const;
|
|
std::vector<const Connection*> GetConnectionsByDestinationSequenced(uint64_t dest, const char* const* classnames, size_t count) const;
|
|
|
|
const std::vector<const AnimationStack*>& AnimationStacks() const;
|
|
|
|
private:
|
|
|
|
std::vector<const Connection*> GetConnectionsSequenced(uint64_t id, const ConnectionMap&) const;
|
|
std::vector<const Connection*> GetConnectionsSequenced(uint64_t id, bool is_src, const ConnectionMap&, const char* const* classnames, size_t count) const;
|
|
|
|
private:
|
|
|
|
void ReadHeader();
|
|
void ReadObjects();
|
|
void ReadPropertyTemplates();
|
|
void ReadConnections();
|
|
|
|
private:
|
|
|
|
const ImportSettings& settings;
|
|
|
|
ObjectMap objects;
|
|
const Parser& parser;
|
|
|
|
PropertyTemplateMap templates;
|
|
ConnectionMap src_connections;
|
|
ConnectionMap dest_connections;
|
|
|
|
unsigned int fbxVersion;
|
|
std::string creator;
|
|
unsigned int creationTimeStamp[7];
|
|
|
|
std::vector<uint64_t> animationStacks;
|
|
mutable std::vector<const AnimationStack*> animationStacksResolved;
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|