godot/modules/fbx/fbx_parser/FBXDocument.h
Rémi Verschelde eb78f80f03
Fix typos with codespell
Using codespell 2.0.0.

Method:
```
$ cat > ../godot-word-whitelist.txt << EOF
ang
curvelinear
dof
doubleclick
fave
findn
GIRD
leapyear
lod
merchantibility
nd
numer
ois
ony
que
seeked
synching
te
uint
unselect
webp
EOF

$ codespell -w -q 3 -I ../godot-word-whitelist.txt --skip="./thirdparty,*.po"
$ git diff // undo unwanted changes
```
2021-05-20 12:56:56 +02:00

1321 lines
35 KiB
C++

/*************************************************************************/
/* FBXDocument.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
/** @file FBXDocument.h
* @brief FBX DOM
*/
#ifndef FBX_DOCUMENT_H
#define FBX_DOCUMENT_H
#include "FBXCommon.h"
#include "FBXParser.h"
#include "FBXProperties.h"
#include "core/math/transform.h"
#include "core/math/vector2.h"
#include "core/math/vector3.h"
#include "core/print_string.h"
#include <stdint.h>
#include <numeric>
#define _AI_CONCAT(a, b) a##b
#define AI_CONCAT(a, b) _AI_CONCAT(a, b)
namespace FBXDocParser {
class Parser;
class Object;
struct ImportSettings;
class Connection;
class PropertyTable;
class Document;
class Material;
class ShapeGeometry;
class LineGeometry;
class Geometry;
class Video;
class AnimationCurve;
class AnimationCurveNode;
class AnimationLayer;
class AnimationStack;
class BlendShapeChannel;
class BlendShape;
class Skin;
class Cluster;
typedef Object *ObjectPtr;
#define new_Object new Object
/** 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 ElementPtr element, const Document &doc);
~LazyObject();
ObjectPtr LoadObject();
/* Casting weak pointers to their templated type safely and preserving ref counting and safety
* with lock() keyword to prevent leaking memory
*/
template <typename T>
const T *Get() {
ObjectPtr ob = LoadObject();
return dynamic_cast<const T *>(ob);
}
uint64_t ID() const {
return id;
}
bool IsBeingConstructed() const {
return (flags & BEING_CONSTRUCTED) != 0;
}
bool FailedToConstruct() const {
return (flags & FAILED_TO_CONSTRUCT) != 0;
}
ElementPtr GetElement() const {
return element;
}
const Document &GetDocument() const {
return doc;
}
private:
const Document &doc;
ElementPtr element = nullptr;
std::shared_ptr<Object> object = nullptr;
const uint64_t id = 0;
enum Flags {
BEING_CONSTRUCTED = 0x1,
FAILED_TO_CONSTRUCT = 0x2
};
unsigned int flags = 0;
};
/** Base class for in-memory (DOM) representations of FBX objects */
class Object {
public:
Object(uint64_t id, const ElementPtr element, const std::string &name);
virtual ~Object();
ElementPtr SourceElement() const {
return element;
}
const std::string &Name() const {
return name;
}
uint64_t ID() const {
return id;
}
protected:
const ElementPtr element;
const std::string name;
const uint64_t id = 0;
};
/** DOM class for generic FBX NoteAttribute blocks. NoteAttribute's just hold a property table,
* fixed members are added by deriving classes. */
class NodeAttribute : public Object {
public:
NodeAttribute(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~NodeAttribute();
const PropertyTable *Props() const {
return props;
}
private:
const PropertyTable *props;
};
/** DOM base class for FBX camera settings attached to a node */
class CameraSwitcher : public NodeAttribute {
public:
CameraSwitcher(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~CameraSwitcher();
int CameraID() const {
return cameraId;
}
const std::string &CameraName() const {
return cameraName;
}
const std::string &CameraIndexName() const {
return cameraIndexName;
}
private:
int cameraId;
std::string cameraName;
std::string cameraIndexName;
};
#define fbx_stringize(a) #a
#define fbx_simple_property(name, type, default_value) \
type name() const { \
return PropertyGet<type>(Props(), fbx_stringize(name), (default_value)); \
}
// XXX improve logging
#define fbx_simple_enum_property(name, type, default_value) \
type name() const { \
const int ival = PropertyGet<int>(Props(), fbx_stringize(name), static_cast<int>(default_value)); \
if (ival < 0 || ival >= AI_CONCAT(type, _MAX)) { \
return static_cast<type>(default_value); \
} \
return static_cast<type>(ival); \
}
class FbxPoseNode;
class FbxPose : public Object {
public:
FbxPose(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
const std::vector<FbxPoseNode *> &GetBindPoses() const {
return pose_nodes;
}
virtual ~FbxPose();
private:
std::vector<FbxPoseNode *> pose_nodes;
};
class FbxPoseNode {
public:
FbxPoseNode(const ElementPtr element, const Document &doc, const std::string &name) {
const ScopePtr sc = GetRequiredScope(element);
// get pose node transform
const ElementPtr Transform = GetRequiredElement(sc, "Matrix", element);
transform = ReadMatrix(Transform);
// get node id this pose node is for
const ElementPtr NodeId = sc->GetElement("Node");
if (NodeId) {
target_id = ParseTokenAsInt64(GetRequiredToken(NodeId, 0));
}
print_verbose("added posenode " + itos(target_id) + " transform: " + transform);
}
virtual ~FbxPoseNode() {
}
uint64_t GetNodeID() const {
return target_id;
}
Transform GetBindPose() const {
return transform;
}
private:
uint64_t target_id;
Transform transform;
};
/** DOM base class for FBX cameras attached to a node */
class Camera : public NodeAttribute {
public:
Camera(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Camera();
fbx_simple_property(Position, Vector3, Vector3(0, 0, 0));
fbx_simple_property(UpVector, Vector3, Vector3(0, 1, 0));
fbx_simple_property(InterestPosition, Vector3, Vector3(0, 0, 0));
fbx_simple_property(AspectWidth, float, 1.0f);
fbx_simple_property(AspectHeight, float, 1.0f);
fbx_simple_property(FilmWidth, float, 1.0f);
fbx_simple_property(FilmHeight, float, 1.0f);
fbx_simple_property(NearPlane, float, 0.1f);
fbx_simple_property(FarPlane, float, 100.0f);
fbx_simple_property(FilmAspectRatio, float, 1.0f);
fbx_simple_property(ApertureMode, int, 0);
fbx_simple_property(FieldOfView, float, 1.0f);
fbx_simple_property(FocalLength, float, 1.0f);
};
/** DOM base class for FBX null markers attached to a node */
class Null : public NodeAttribute {
public:
Null(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Null();
};
/** DOM base class for FBX limb node markers attached to a node */
class LimbNode : public NodeAttribute {
public:
LimbNode(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~LimbNode();
};
/** DOM base class for FBX lights attached to a node */
class Light : public NodeAttribute {
public:
Light(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Light();
enum Type {
Type_Point,
Type_Directional,
Type_Spot,
Type_Area,
Type_Volume,
Type_MAX // end-of-enum sentinel
};
enum Decay {
Decay_None,
Decay_Linear,
Decay_Quadratic,
Decay_Cubic,
Decay_MAX // end-of-enum sentinel
};
fbx_simple_property(Color, Vector3, Vector3(1, 1, 1));
fbx_simple_enum_property(LightType, Type, 0);
fbx_simple_property(CastLightOnObject, bool, false);
fbx_simple_property(DrawVolumetricLight, bool, true);
fbx_simple_property(DrawGroundProjection, bool, true);
fbx_simple_property(DrawFrontFacingVolumetricLight, bool, false);
fbx_simple_property(Intensity, float, 100.0f);
fbx_simple_property(InnerAngle, float, 0.0f);
fbx_simple_property(OuterAngle, float, 45.0f);
fbx_simple_property(Fog, int, 50);
fbx_simple_enum_property(DecayType, Decay, 2);
fbx_simple_property(DecayStart, float, 1.0f);
fbx_simple_property(FileName, std::string, "");
fbx_simple_property(EnableNearAttenuation, bool, false);
fbx_simple_property(NearAttenuationStart, float, 0.0f);
fbx_simple_property(NearAttenuationEnd, float, 0.0f);
fbx_simple_property(EnableFarAttenuation, bool, false);
fbx_simple_property(FarAttenuationStart, float, 0.0f);
fbx_simple_property(FarAttenuationEnd, float, 0.0f);
fbx_simple_property(CastShadows, bool, true);
fbx_simple_property(ShadowColor, Vector3, Vector3(0, 0, 0));
fbx_simple_property(AreaLightShape, int, 0);
fbx_simple_property(LeftBarnDoor, float, 20.0f);
fbx_simple_property(RightBarnDoor, float, 20.0f);
fbx_simple_property(TopBarnDoor, float, 20.0f);
fbx_simple_property(BottomBarnDoor, float, 20.0f);
fbx_simple_property(EnableBarnDoor, bool, true);
};
class Model;
typedef Model *ModelPtr;
#define new_Model new Model
/** DOM base class for FBX models (even though its semantics are more "node" than "model" */
class Model : public Object {
public:
enum RotOrder {
RotOrder_EulerXYZ = 0,
RotOrder_EulerXZY,
RotOrder_EulerYZX,
RotOrder_EulerYXZ,
RotOrder_EulerZXY,
RotOrder_EulerZYX,
RotOrder_SphericXYZ,
RotOrder_MAX // end-of-enum sentinel
};
Model(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Model();
fbx_simple_property(QuaternionInterpolate, int, 0);
fbx_simple_property(RotationOffset, Vector3, Vector3());
fbx_simple_property(RotationPivot, Vector3, Vector3());
fbx_simple_property(ScalingOffset, Vector3, Vector3());
fbx_simple_property(ScalingPivot, Vector3, Vector3());
fbx_simple_property(TranslationActive, bool, false);
fbx_simple_property(TranslationMin, Vector3, Vector3());
fbx_simple_property(TranslationMax, Vector3, Vector3());
fbx_simple_property(TranslationMinX, bool, false);
fbx_simple_property(TranslationMaxX, bool, false);
fbx_simple_property(TranslationMinY, bool, false);
fbx_simple_property(TranslationMaxY, bool, false);
fbx_simple_property(TranslationMinZ, bool, false);
fbx_simple_property(TranslationMaxZ, bool, false);
fbx_simple_enum_property(RotationOrder, RotOrder, 0);
fbx_simple_property(RotationSpaceForLimitOnly, bool, false);
fbx_simple_property(RotationStiffnessX, float, 0.0f);
fbx_simple_property(RotationStiffnessY, float, 0.0f);
fbx_simple_property(RotationStiffnessZ, float, 0.0f);
fbx_simple_property(AxisLen, float, 0.0f);
fbx_simple_property(PreRotation, Vector3, Vector3());
fbx_simple_property(PostRotation, Vector3, Vector3());
fbx_simple_property(RotationActive, bool, false);
fbx_simple_property(RotationMin, Vector3, Vector3());
fbx_simple_property(RotationMax, Vector3, Vector3());
fbx_simple_property(RotationMinX, bool, false);
fbx_simple_property(RotationMaxX, bool, false);
fbx_simple_property(RotationMinY, bool, false);
fbx_simple_property(RotationMaxY, bool, false);
fbx_simple_property(RotationMinZ, bool, false);
fbx_simple_property(RotationMaxZ, bool, false);
fbx_simple_enum_property(InheritType, TransformInheritance, 0);
fbx_simple_property(ScalingActive, bool, false);
fbx_simple_property(ScalingMin, Vector3, Vector3());
fbx_simple_property(ScalingMax, Vector3, Vector3(1, 1, 1));
fbx_simple_property(ScalingMinX, bool, false);
fbx_simple_property(ScalingMaxX, bool, false);
fbx_simple_property(ScalingMinY, bool, false);
fbx_simple_property(ScalingMaxY, bool, false);
fbx_simple_property(ScalingMinZ, bool, false);
fbx_simple_property(ScalingMaxZ, bool, false);
fbx_simple_property(GeometricTranslation, Vector3, Vector3());
fbx_simple_property(GeometricRotation, Vector3, Vector3());
fbx_simple_property(GeometricScaling, Vector3, Vector3(1, 1, 1));
fbx_simple_property(MinDampRangeX, float, 0.0f);
fbx_simple_property(MinDampRangeY, float, 0.0f);
fbx_simple_property(MinDampRangeZ, float, 0.0f);
fbx_simple_property(MaxDampRangeX, float, 0.0f);
fbx_simple_property(MaxDampRangeY, float, 0.0f);
fbx_simple_property(MaxDampRangeZ, float, 0.0f);
fbx_simple_property(MinDampStrengthX, float, 0.0f);
fbx_simple_property(MinDampStrengthY, float, 0.0f);
fbx_simple_property(MinDampStrengthZ, float, 0.0f);
fbx_simple_property(MaxDampStrengthX, float, 0.0f);
fbx_simple_property(MaxDampStrengthY, float, 0.0f);
fbx_simple_property(MaxDampStrengthZ, float, 0.0f);
fbx_simple_property(PreferredAngleX, float, 0.0f);
fbx_simple_property(PreferredAngleY, float, 0.0f);
fbx_simple_property(PreferredAngleZ, float, 0.0f);
fbx_simple_property(Show, bool, true);
fbx_simple_property(LODBox, bool, false);
fbx_simple_property(Freeze, bool, false);
const std::string &Shading() const {
return shading;
}
const std::string &Culling() const {
return culling;
}
const PropertyTable *Props() const {
return props;
}
/** Get material links */
const std::vector<const Material *> &GetMaterials() const {
return materials;
}
/** Get geometry links */
const std::vector<const Geometry *> &GetGeometry() const {
return geometry;
}
/** Get node attachments */
const std::vector<const NodeAttribute *> &GetAttributes() const {
return attributes;
}
/** convenience method to check if the node has a Null node marker */
bool IsNull() const;
private:
void ResolveLinks(const ElementPtr element, const Document &doc);
private:
std::vector<const Material *> materials;
std::vector<const Geometry *> geometry;
std::vector<const NodeAttribute *> attributes;
std::string shading;
std::string culling;
const PropertyTable *props = nullptr;
};
class ModelLimbNode : public Model {
public:
ModelLimbNode(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~ModelLimbNode();
};
/** DOM class for generic FBX textures */
class Texture : public Object {
public:
Texture(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Texture();
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 Vector2 &UVTranslation() const {
return uvTrans;
}
const Vector2 &UVScaling() const {
return uvScaling;
}
const PropertyTable *Props() const {
return props;
}
// return a 4-tuple
const unsigned int *Crop() const {
return crop;
}
const Video *Media() const {
return media;
}
private:
Vector2 uvTrans;
Vector2 uvScaling;
std::string type;
std::string relativeFileName;
std::string fileName;
std::string alphaSource;
const PropertyTable *props = nullptr;
unsigned int crop[4] = { 0 };
const Video *media = nullptr;
};
/** DOM class for layered FBX textures */
class LayeredTexture : public Object {
public:
LayeredTexture(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~LayeredTexture();
// Can only be called after construction of the layered texture object due to construction flag.
void fillTexture(const Document &doc);
enum BlendMode {
BlendMode_Translucent,
BlendMode_Additive,
BlendMode_Modulate,
BlendMode_Modulate2,
BlendMode_Over,
BlendMode_Normal,
BlendMode_Dissolve,
BlendMode_Darken,
BlendMode_ColorBurn,
BlendMode_LinearBurn,
BlendMode_DarkerColor,
BlendMode_Lighten,
BlendMode_Screen,
BlendMode_ColorDodge,
BlendMode_LinearDodge,
BlendMode_LighterColor,
BlendMode_SoftLight,
BlendMode_HardLight,
BlendMode_VividLight,
BlendMode_LinearLight,
BlendMode_PinLight,
BlendMode_HardMix,
BlendMode_Difference,
BlendMode_Exclusion,
BlendMode_Subtract,
BlendMode_Divide,
BlendMode_Hue,
BlendMode_Saturation,
BlendMode_Color,
BlendMode_Luminosity,
BlendMode_Overlay,
BlendMode_BlendModeCount
};
const Texture *getTexture(int index = 0) const {
return textures[index];
}
int textureCount() const {
return static_cast<int>(textures.size());
}
BlendMode GetBlendMode() const {
return blendMode;
}
float Alpha() {
return alpha;
}
private:
std::vector<const Texture *> textures;
BlendMode blendMode;
float alpha;
};
typedef std::map<std::string, const Texture *> TextureMap;
typedef std::map<std::string, const LayeredTexture *> LayeredTextureMap;
/** DOM class for generic FBX videos */
class Video : public Object {
public:
Video(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Video();
const std::string &Type() const {
return type;
}
bool IsEmbedded() const {
return contentLength > 0;
}
const std::string &FileName() const {
return fileName;
}
const std::string &RelativeFilename() const {
return relativeFileName;
}
const PropertyTable *Props() const {
return props;
}
const uint8_t *Content() const {
return content;
}
uint64_t ContentLength() const {
return contentLength;
}
uint8_t *RelinquishContent() {
uint8_t *ptr = content;
content = nullptr;
return ptr;
}
bool operator==(const Video &other) const {
return (
type == other.type && relativeFileName == other.relativeFileName && fileName == other.fileName);
}
bool operator<(const Video &other) const {
return std::tie(type, relativeFileName, fileName) < std::tie(other.type, other.relativeFileName, other.fileName);
}
private:
std::string type;
std::string relativeFileName;
std::string fileName;
const PropertyTable *props = nullptr;
uint64_t contentLength;
uint8_t *content;
};
/** DOM class for generic FBX materials */
class Material : public Object {
public:
Material(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Material();
const std::string &GetShadingModel() const {
return shading;
}
bool IsMultilayer() const {
return multilayer;
}
const PropertyTable *Props() const {
return props;
}
const TextureMap &Textures() const {
return textures;
}
const LayeredTextureMap &LayeredTextures() const {
return layeredTextures;
}
private:
std::string shading;
bool multilayer;
const PropertyTable *props;
TextureMap textures;
LayeredTextureMap layeredTextures;
};
// signed int keys (this can happen!)
typedef std::vector<int64_t> KeyTimeList;
typedef std::vector<float> KeyValueList;
/** Represents a FBX animation curve (i.e. a 1-dimensional set of keyframes and values therefore) */
class AnimationCurve : public Object {
public:
AnimationCurve(uint64_t id, const ElementPtr element, const std::string &name, const Document &doc);
virtual ~AnimationCurve();
/** 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::map<int64_t, float> &GetValueTimeTrack() const {
return keyvalues;
}
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::map<int64_t, float> keyvalues;
std::vector<unsigned int> flags;
};
/* Typedef for pointers for the animation handler */
typedef std::shared_ptr<AnimationCurve> AnimationCurvePtr;
typedef std::weak_ptr<AnimationCurve> AnimationCurveWeakPtr;
typedef std::map<std::string, const AnimationCurve *> AnimationMap;
/* Animation Curve node ptr */
typedef std::shared_ptr<AnimationCurveNode> AnimationCurveNodePtr;
typedef std::weak_ptr<AnimationCurveNode> AnimationCurveNodeWeakPtr;
/** Represents a FBX animation curve (i.e. a mapping from single animation curves to nodes) */
class AnimationCurveNode : public Object {
public:
/* the optional white list specifies a list of property names for which the caller
wants animations for. If the curve node does not match one of these, std::range_error
will be thrown. */
AnimationCurveNode(uint64_t id, const ElementPtr element, const std::string &name, const Document &doc,
const char *const *target_prop_whitelist = nullptr, size_t whitelist_size = 0);
virtual ~AnimationCurveNode();
const PropertyTable *Props() const {
return props;
}
const AnimationMap &Curves() const;
/** Object the curve is assigned to, this can be NULL if the
* target object has no DOM representation or could not
* be read for other reasons.*/
Object *Target() const {
return target;
}
Model *TargetAsModel() const {
return dynamic_cast<Model *>(target);
}
NodeAttribute *TargetAsNodeAttribute() const {
return dynamic_cast<NodeAttribute *>(target);
}
/** Property of Target() that is being animated*/
const std::string &TargetProperty() const {
return prop;
}
private:
Object *target = nullptr;
const PropertyTable *props;
mutable AnimationMap curves;
std::string prop;
const Document &doc;
};
typedef std::vector<const AnimationCurveNode *> AnimationCurveNodeList;
typedef std::shared_ptr<AnimationLayer> AnimationLayerPtr;
typedef std::weak_ptr<AnimationLayer> AnimationLayerWeakPtr;
typedef std::vector<const AnimationLayer *> AnimationLayerList;
/** Represents a FBX animation layer (i.e. a list of node animations) */
class AnimationLayer : public Object {
public:
AnimationLayer(uint64_t id, const ElementPtr element, const std::string &name, const Document &doc);
virtual ~AnimationLayer();
const PropertyTable *Props() const {
//ai_assert(props.get());
return props;
}
/* the optional white list specifies a list of property names for which the caller
wants animations for. Curves not matching this list will not be added to the
animation layer. */
const AnimationCurveNodeList Nodes(const char *const *target_prop_whitelist = nullptr, size_t whitelist_size = 0) const;
private:
const PropertyTable *props;
const Document &doc;
};
/** Represents a FBX animation stack (i.e. a list of animation layers) */
class AnimationStack : public Object {
public:
AnimationStack(uint64_t id, const ElementPtr element, const std::string &name, const Document &doc);
virtual ~AnimationStack();
fbx_simple_property(LocalStart, int64_t, 0L);
fbx_simple_property(LocalStop, int64_t, 0L);
fbx_simple_property(ReferenceStart, int64_t, 0L);
fbx_simple_property(ReferenceStop, int64_t, 0L);
const PropertyTable *Props() const {
return props;
}
const AnimationLayerList &Layers() const {
return layers;
}
private:
const PropertyTable *props = nullptr;
AnimationLayerList layers;
};
/** DOM class for deformers */
class Deformer : public Object {
public:
Deformer(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Deformer();
const PropertyTable *Props() const {
//ai_assert(props.get());
return props;
}
private:
const PropertyTable *props;
};
/** Constraints are from Maya they can help us with BoneAttachments :) **/
class Constraint : public Object {
public:
Constraint(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Constraint();
private:
const PropertyTable *props;
};
typedef std::vector<float> WeightArray;
typedef std::vector<unsigned int> WeightIndexArray;
/** DOM class for BlendShapeChannel deformers */
class BlendShapeChannel : public Deformer {
public:
BlendShapeChannel(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~BlendShapeChannel();
float DeformPercent() const {
return percent;
}
const WeightArray &GetFullWeights() const {
return fullWeights;
}
const std::vector<const ShapeGeometry *> &GetShapeGeometries() const {
return shapeGeometries;
}
private:
float percent;
WeightArray fullWeights;
std::vector<const ShapeGeometry *> shapeGeometries;
};
/** DOM class for BlendShape deformers */
class BlendShape : public Deformer {
public:
BlendShape(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~BlendShape();
const std::vector<const BlendShapeChannel *> &BlendShapeChannels() const {
return blendShapeChannels;
}
private:
std::vector<const BlendShapeChannel *> blendShapeChannels;
};
/** DOM class for skin deformer clusters (aka sub-deformers) */
class Cluster : public Deformer {
public:
Cluster(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Cluster();
/** get the list of deformer weights associated with this cluster.
* Use #GetIndices() to get the associated vertices. Both arrays
* have the same size (and may also be empty). */
const std::vector<float> &GetWeights() const {
return weights;
}
/** get indices into the vertex data of the geometry associated
* with this cluster. Use #GetWeights() to get the associated weights.
* Both arrays have the same size (and may also be empty). */
const std::vector<unsigned int> &GetIndices() const {
return indices;
}
/** */
const Transform &GetTransform() const {
return transform;
}
const Transform &TransformLink() const {
return transformLink;
}
const Model *TargetNode() const {
return node;
}
const Transform &TransformAssociateModel() const {
return transformAssociateModel;
}
bool TransformAssociateModelValid() const {
return valid_transformAssociateModel;
}
// property is not in the fbx file
// if the cluster has an associate model
// we then have an additive type
enum SkinLinkMode {
SkinLinkMode_Normalized = 0,
SkinLinkMode_Additive = 1
};
SkinLinkMode GetLinkMode() {
return link_mode;
}
private:
std::vector<float> weights;
std::vector<unsigned int> indices;
Transform transform;
Transform transformLink;
Transform transformAssociateModel;
SkinLinkMode link_mode;
bool valid_transformAssociateModel;
const Model *node = nullptr;
};
/** DOM class for skin deformers */
class Skin : public Deformer {
public:
Skin(uint64_t id, const ElementPtr element, const Document &doc, const std::string &name);
virtual ~Skin();
float DeformAccuracy() const {
return accuracy;
}
const std::vector<const Cluster *> &Clusters() const {
return clusters;
}
enum SkinType {
Skin_Rigid = 0,
Skin_Linear,
Skin_DualQuaternion,
Skin_Blend
};
const SkinType &GetSkinType() const {
return skinType;
}
private:
float accuracy;
SkinType skinType;
std::vector<const Cluster *> clusters;
};
/** 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.
Object *SourceObject() 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 {
//ai_assert(nullptr != c);
// 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 {
//ai_assert(nullptr != c);
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::map<std::string, const PropertyTable *> PropertyTemplateMap;
typedef std::multimap<uint64_t, const Connection *> ConnectionMap;
/** DOM class for global document settings, a single instance per document can
* be accessed via Document.Globals(). */
class FileGlobalSettings {
public:
FileGlobalSettings(const Document &doc, const PropertyTable *props);
~FileGlobalSettings();
const PropertyTable *Props() const {
return props;
}
const Document &GetDocument() const {
return doc;
}
fbx_simple_property(UpAxis, int, 1);
fbx_simple_property(UpAxisSign, int, 1);
fbx_simple_property(FrontAxis, int, 2);
fbx_simple_property(FrontAxisSign, int, 1);
fbx_simple_property(CoordAxis, int, 0);
fbx_simple_property(CoordAxisSign, int, 1);
fbx_simple_property(OriginalUpAxis, int, 0);
fbx_simple_property(OriginalUpAxisSign, int, 1);
fbx_simple_property(UnitScaleFactor, float, 1);
fbx_simple_property(OriginalUnitScaleFactor, float, 1);
fbx_simple_property(AmbientColor, Vector3, Vector3(0, 0, 0));
fbx_simple_property(DefaultCamera, std::string, "");
enum FrameRate {
FrameRate_DEFAULT = 0,
FrameRate_120 = 1,
FrameRate_100 = 2,
FrameRate_60 = 3,
FrameRate_50 = 4,
FrameRate_48 = 5,
FrameRate_30 = 6,
FrameRate_30_DROP = 7,
FrameRate_NTSC_DROP_FRAME = 8,
FrameRate_NTSC_FULL_FRAME = 9,
FrameRate_PAL = 10,
FrameRate_CINEMA = 11,
FrameRate_1000 = 12,
FrameRate_CINEMA_ND = 13,
FrameRate_CUSTOM = 14,
FrameRate_MAX // end-of-enum sentinel
};
fbx_simple_enum_property(TimeMode, FrameRate, FrameRate_DEFAULT);
fbx_simple_property(TimeSpanStart, uint64_t, 0L);
fbx_simple_property(TimeSpanStop, uint64_t, 0L);
fbx_simple_property(CustomFrameRate, float, -1.0f);
private:
const PropertyTable *props = nullptr;
const Document &doc;
};
/** DOM root for a FBX file */
class Document {
public:
Document(const Parser &parser, const ImportSettings &settings);
~Document();
LazyObject *GetObject(uint64_t id) const;
bool IsSafeToImport() const {
return SafeToImport;
}
bool IsBinary() const {
return parser.IsBinary();
}
unsigned int FBXVersion() const {
return fbxVersion;
}
const std::string &Creator() const {
return creator;
}
// elements (in this order): Year, Month, Day, Hour, Second, Millisecond
const unsigned int *CreationTimeStamp() const {
return creationTimeStamp;
}
const FileGlobalSettings *GlobalSettingsPtr() const {
return globals.get();
}
const PropertyTable *GetMetadataProperties() const {
return metadata_properties;
}
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;
const std::vector<uint64_t> &GetAnimationStackIDs() const {
return animationStacks;
}
const std::vector<uint64_t> &GetConstraintStackIDs() const {
return constraints;
}
const std::vector<uint64_t> &GetBindPoseIDs() const {
return bind_poses;
};
const std::vector<uint64_t> &GetMaterialIDs() const {
return materials;
};
const std::vector<uint64_t> &GetSkinIDs() const {
return skins;
}
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;
bool ReadHeader();
void ReadObjects();
void ReadPropertyTemplates();
void ReadConnections();
void ReadGlobalSettings();
private:
const ImportSettings &settings;
ObjectMap objects;
const Parser &parser;
bool SafeToImport = false;
PropertyTemplateMap templates;
ConnectionMap src_connections;
ConnectionMap dest_connections;
unsigned int fbxVersion = 0;
std::string creator;
unsigned int creationTimeStamp[7] = { 0 };
std::vector<uint64_t> animationStacks;
std::vector<uint64_t> bind_poses;
// constraints aren't in the tree / at least they are not easy to access.
std::vector<uint64_t> constraints;
std::vector<uint64_t> materials;
std::vector<uint64_t> skins;
mutable std::vector<const AnimationStack *> animationStacksResolved;
PropertyTable *metadata_properties = nullptr;
std::shared_ptr<FileGlobalSettings> globals = nullptr;
};
} // namespace FBXDocParser
namespace std {
template <>
struct hash<const FBXDocParser::Video> {
std::size_t operator()(const FBXDocParser::Video &video) const {
using std::hash;
using std::size_t;
using std::string;
size_t res = 17;
res = res * 31 + hash<string>()(video.Name());
res = res * 31 + hash<string>()(video.RelativeFilename());
res = res * 31 + hash<string>()(video.Type());
return res;
}
};
} // namespace std
#endif // FBX_DOCUMENT_H