Fbx Exporter : fixed missing .h files from FBX sdk

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/scene/geometry/fbxlodgroup.h

@@ -0,0 +1,322 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxlodgroup.h
+#ifndef _FBXSDK_SCENE_GEOMETRY_LOD_GROUP_H_
+#define _FBXSDK_SCENE_GEOMETRY_LOD_GROUP_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/scene/geometry/fbxnodeattribute.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+/** Defines a LOD (Level of Detail) group.
+  * This LodGroup node is a group node that can be used to detect how
+  * close a group of objects is to a camera. Typically this node is
+  * used for controlling "Level of Detail" visibility.
+  *
+  * Properties in the class are designed according to Maya implementation.
+  * So these properties may be incompatible with other software, like 3ds Max.
+  *
+  * In Maya, with "Level of Detail",the visibility of the children of this 
+  * transform are controlled by the distance of a group to the camera and the
+  * threshold values.
+  *
+  * For example, under a LOD group node, there are three children:
+  * ship_detailed, ship_medium, and ship_rough. There are 2 threshold 
+  * values: 5, 10.  When the camera is less than 5 units away of the group 
+  * bounding box, only ship_detailed is visible. When the view is zoomed out and
+  * the camera is between 5 and 10 units away from the group, only ship_medium is
+  * visible. Finally, when the view is zoomed out more and the camera is 10 or 
+  * more units away from the group, only ship_rough is visible.
+  *
+  * This node attribute contains the properties of a null node.
+  *
+  * Example code to create LODGroup:
+  *	\code
+  * FbxNode *lLodGroup = FbxNode::Create(pScene, "LODNode");
+  * FbxLODGroup *lLodGroupAttr = FbxLODGroup::Create(pScene, "LODGroup1");
+  * // Array lChildNodes contains geometries of all LOD levels
+  * for (int j = 0; j < lChildNodes.GetCount(); j++)
+  * {
+  *    lLodGroup->AddChild(lChildNodes.GetAt(j));
+  * }
+  * \endcode
+  *
+  * This object can also be configured to define thresholds as percentage values.
+  * Typically, these percentage values represent the ratio between the group bounding
+  * box height (in screen space) and the viewing screen height.
+  *
+  * To switch to this mode, the client application must set the value of the 
+  * ThresholdsUsedAsPercentage property to "true" before the calls to the AddThreshold/
+  * SetThreshold methods. Client applications should always check the return value of
+  * these methods to validate that the action was successful. 
+  * 
+  * Note that, for backward compatibility, the data is always stored as FbxDistance type.
+  * The client application should always check the return value of this method to validate
+  * that the argument contains a meaningful value (see GetThreshold for more details).
+  *
+  * Example code to create LODGroup that store percentage values:
+  *	\code
+  * FbxNode *lLodGroup = FbxNode::Create(pScene, "LODNode");
+  * FbxLODGroup *lLodGroupAttr = FbxLODGroup::Create(pScene, "LODGroup1");
+  * lLodGroupAttr->ThresholdsUsedAsPercentage.Set(true);
+  * FBX_ASSERT(lLodGroupAttr->AddThreshold(33.3)) == true);
+  * FBX_ASSERT(lLodGroupAttr->AddThreshold(66.6)) == true);
+  * FBX_ASSERT(lLodGroupAttr->AddThreshold(FbxDistance(0.6f, "cm")) == false);
+  *
+  * FbxDistance dval;
+  * FbxDouble val = 0.0;
+  * bool res;
+  * res = lLodGroupAttr->GetThreshold(0, val);  // res = true, val = 33.3
+  * res = lLodGroupAttr->GetThreshold(0, dval); // res = false, dval.value()=33.3
+  * res = lLodGroupAttr->GetThreshold(2, val);  // res = false, val = 1.0
+  * \nosubgrouping
+  */
+class FBXSDK_DLL FbxLODGroup : public FbxNodeAttribute
+{
+    FBXSDK_OBJECT_DECLARE(FbxLODGroup, FbxNodeAttribute);
+
+public:
+    //! Return the type of node attribute which is EType::eLODGroup.
+    virtual FbxNodeAttribute::EType GetAttributeType() const;
+
+    /** \enum EDisplayLevel types to determine how to display nodes in LODGroup.
+      * - \e eUseLOD Display the node according LOD threshold
+      * - \e eShow Always show this node
+	  * - \e eHide Always hide this node
+      */
+	enum EDisplayLevel
+	{
+		eUseLOD,
+		eShow,
+		eHide
+	};
+
+    //////////////////////////////////////////////////////////////////////////
+    //
+    // Properties
+    //
+    //////////////////////////////////////////////////////////////////////////
+	/** Specifies if the threshold values stored by this LOD object are defining
+	  * a distance to the camera (by default) or a percentage value.
+	  *
+	  * \remarks This property needs to be set before any call to the Add\SetThreshold
+	  *          methods since its value is used to validate that the correct method is
+	  *          called.
+	  *
+      * To access this property do: ThresholdsUsedAsPercentage.Get().
+      * To set this property do: ThresholdsUsedAsPercentage.Set(bool).
+      *
+      * Default value is false
+	  */
+	FbxPropertyT<FbxBool>  ThresholdsUsedAsPercentage;
+
+	/**
+	  * \name Distance Mode
+	  * The properties in this block are meaningful only if ThresholdsUsedAsPercentage
+	  * is set to false and should be ignored otherwise.
+	  */
+	//@{
+		/** This property handles the use of the Min/Max distances.
+		  * Enables the minimum and maximum distance to take effect.
+		  * For example, if the distance between the group and the camera is smaller 
+		  * than the minimum distance, then the whole group disappears.
+		  *
+		  * To access this property do: MinMaxDistance.Get().
+		  * To set this property do: MinMaxDistance.Set(bool).
+		  *
+		  * Default value is false.
+		  */
+		FbxPropertyT<FbxBool>       MinMaxDistance;
+
+		/** The minimum distance at which the group is displayed.
+		  *
+		  * To access this property do: MinDistance.Get().
+		  * To set this property do: MinDistance.Set(double).
+		  *
+		  * Default value is -100
+		  */
+		FbxPropertyT<FbxDouble>     MinDistance;
+
+		/** The maximum distance at which the group is displayed. 
+		  *
+		  * To access this property do: MaxDistance.Get().
+		  * To set this property do: MaxDistance.Set(double).
+		  *
+		  * Default value is 100
+		  */
+		FbxPropertyT<FbxDouble>     MaxDistance;
+
+		/** Work in world space of transform or local space If true, 
+		  * the camera distance to the LOD group will be computed in world space.
+		  * This means it is possible to parent the LOD transform below other transforms 
+		  * and still have it work as expected. If this attribute is set to false,
+		  * the distance computation ignores any parent transforms of the LOD transform. 
+		  *
+		  * To access this property do: WorldSpace.Get().
+		  * To set this property do: WorldSpace.Set(bool).
+		  *
+		  * Default value is false
+		  */
+		FbxPropertyT<FbxBool>       WorldSpace;
+	//@}
+
+    //////////////////////////////////////////////////////////////////////////
+    //
+    // Methods
+    //
+    //////////////////////////////////////////////////////////////////////////
+
+	/** Get the number of elements in the threshold list.
+	  * In correct situations, the size of this list is one less than the LOD node
+	  * children objects count.
+	  * \return The current size of the threshold list.
+	  */
+	int GetNumThresholds() const;
+
+	/** Add a new threshold. 
+	  * \param pThreshValue Threshold value (distance).
+	  * \return true if successful and false otherwise.
+	  * \remarks The thresholds list can only expand. Removing items is not
+	  *          possible unless a new FbxLODGroup is created to replace this one.
+	  * \remarks This method does not check the received value and blindly adds it
+	  *          to the list. Identical values can exist in different positions in
+	  *          the list.
+	  * \remarks This method will fail if ThresholdsUsedAsPercentage=true.
+	  */
+	bool AddThreshold(const FbxDistance& pThreshValue);
+
+	/** Add a new threshold. 
+	  * \param pThreshValue Threshold value (percentage).
+	  * \return true if successful and false otherwise.
+	  * \remarks The thresholds list can only expand. Removing items is not
+	  *          possible unless a new FbxLODGroup is created to replace this one.
+	  * \remarks This method does not check the received value and blindly adds it
+	  *          to the list. Identical values can exist in different positions in
+	  *          the list.
+	  * \remarks This method will fail if ThresholdsUsedAsPercentage=false.
+	  */
+	bool AddThreshold(FbxDouble pThreshValue);
+
+	/** Replace the value of the specified threshold.
+	  * \param pEl Element index in the thresholds list.
+	  * \param pThreshValue New threshold value (distance).
+	  * \return true if successful and false otherwise.
+	  * \remarks This method will fail if ThresholdsUsedAsPercentage=true.
+	  */
+	bool SetThreshold(int pEl, const FbxDistance& pThreshValue);
+
+	/** Replace the value of the specified threshold.
+	  * \param pEl Element index in the thresholds list.
+	  * \param pThreshValue New threshold value (percentage).
+	  * \return true if successful and false otherwise.
+	  * \remarks This method will fail if ThresholdsUsedAsPercentage=false.
+	  */
+	bool SetThreshold(int pEl, FbxDouble pThreshValue);
+
+	/** Get the value of the specified threshold.
+      * \param pEl Element index in the thresholds list.
+	  * \param pThreshValue The current threshold value.
+	  * \return true if successful and false otherwise.  
+	  * \remarks pThreshValue is left unchanged if a bad index is provided, 
+	  *          else the value stored in the list is returned in pThreshValue
+	  *          but may be irrelevant if ThresholdsUsedAsPercentage=true. In
+      *          this case, the return of this function will also be \c false.
+	  */
+	bool GetThreshold(int pEl, FbxDistance& pThreshValue) const;
+
+	/** Get the value of the specified threshold.
+      * \param pEl Element index in the thresholds list.
+	  * \param pThreshValue The current threshold value.
+	  * \return true if successful and false otherwise.
+	  * \remarks pThreshValue is left unchanged if a bad index is provided, 
+	  *          else the value stored in the list is returned in pThreshValue
+	  *          but may be irrelevant if ThresholdsUsedAsPercentage=false. In
+      *          this case, the return of this function will also be \c false.
+	  */
+	bool GetThreshold(int pEl, FbxDouble& pThreshValue) const;
+
+	/** Get the number of elements in the displayLevel list.
+	  * In correct situations, the size of this list equals the LOD node
+	  * children objects count.
+	  * \return The current size of the displayLevel list.
+	  */
+	int GetNumDisplayLevels() const;
+
+	/** Add a new displayLevel value to the current list.
+	  *
+	  * The value overrides the display of any level and can force it to hide 
+	  * or show the object at that level. For example, if the distance between
+	  * the group and the camera is smaller than the first threshold, then the 
+	  * object at level 0 is visible. If the display level for the object at 
+	  * level 2 is changed to eShow, ie. if the attribute displayLevel[2] is 
+	  * set to eShow, then the object at level 2 will show regardless of
+	  * the current active level. 
+	  *
+	  * \param pValue Display level value
+	  * \return true if successful and false if any error occurred.
+	  * \remarks Removing items is not possible unless a new FbxLODGroup is 
+	  *          created to replace this one.
+	  * \remarks This method does not check the received value and blindly adds it
+	  *          to the list. Identical values can exist in different positions in
+	  *          the list.
+	  */
+	bool AddDisplayLevel(FbxLODGroup::EDisplayLevel pValue);
+
+	/** Set the display level value for the specified child object.
+	  * \param pEl The index of the object.
+	  * \param pValue New display level value.
+	  * \return true if successful and false otherwise.
+	  */
+	bool SetDisplayLevel(int pEl, FbxLODGroup::EDisplayLevel pValue);
+
+	/** Get the display level value for the specified child object.
+      * \param pEl The index of the object.
+	  * \param pValue the current display level value.
+	  * \return true if successful and false otherwise.
+	  * \remarks In case of failure, the pValue is left unchanged.
+	  */
+	bool GetDisplayLevel(int pEl, FbxLODGroup::EDisplayLevel& pValue) const;
+	
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    virtual FbxObject& Copy(const FbxObject& pObject);
+
+protected:
+	virtual void Construct(const FbxObject* pFrom);
+    virtual void ConstructProperties(bool pForceSet);
+
+private:
+	int mNbThresholds;
+	FbxProperty mThresholds;
+
+	bool RetrieveThreshold(int pEl, FbxDistance& pThreshValue) const;
+	bool StoreThreshold(int pEl, const FbxDistance& pThreshValue);
+
+	int mNbDisplayLevels;
+	FbxProperty mDisplayLevels;
+
+	bool DisplayLevel(int pEl, FbxLODGroup::EDisplayLevel pValue);
+
+public:
+    virtual FbxStringList GetTypeFlags() const;
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+inline EFbxType FbxTypeOf(const FbxLODGroup::EDisplayLevel&){ return eFbxEnum; }
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_SCENE_GEOMETRY_LOD_GROUP_H_ */

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/utils/fbxmanipulators.h

@@ -0,0 +1,169 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxmanipulators.h
+#ifndef _FBXSDK_UTILS_MANIPULATORS_H_
+#define _FBXSDK_UTILS_MANIPULATORS_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/core/fbxobject.h>
+#include <fbxsdk/core/math/fbxvector2.h>
+#include <fbxsdk/core/math/fbxvector4.h>
+#include <fbxsdk/scene/geometry/fbxcamera.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+class FbxCameraManipulationState;
+
+/** This class can be used to provide basic camera manipulation in any program using this library.
+  * \nosubgrouping
+  */
+class FBXSDK_DLL FbxCameraManipulator : public FbxObject
+{
+	FBXSDK_OBJECT_DECLARE(FbxCameraManipulator, FbxObject);
+
+public:
+	//! All possible manipulation actions that can be performed on a camera using this manipulator.
+	enum EAction
+	{
+		eNone,		//!< No action.
+		eOrbit,		//!< Orbiting camera around LootAt/Interest position.
+		eDolly,		//!< Moving camera closer or away from its LookAt/Intest position.
+		ePan,		//!< Panning camera up, down and sideways.
+		eFreePan	//!< Panning and dollying all at once.
+	};
+
+	/** Begin manipulation of the camera.
+	* \param pAction The action performed for this manipulation scope.
+	* \param pX Begin horizontal position of the manipulation, in pixels.
+	* \param pY Begin vertical position of the manipulation, in pixels. */
+	void Begin(EAction pAction, float pX, float pY);
+
+	/** Notify manipulation of latest input.
+	* \param pTimeDelta Elapsed time since the last notify. Only used if Smoothing is enabled.
+	* \param pX Horizontal position of the manipulation, in pixels.
+	* \param pY Vertical position of the manipulation, in pixels.
+	* \param pScale Scaling value of the manipulation. Only used by eFreePan action. */
+	void Notify(float pX, float pY, float pScale=0);
+
+	//! End current manipulation.
+	void End();
+
+	/** Update the camera position. This must be called periodically in order for the camera to update its position.
+	* \param pTimeDelta Elapsed time since the last update. If Smooth is disabled, you can leave this value to zero.
+	* \remark Begin, Notify and End will not change the current camera position. */
+	void Update(const FbxTime& pTimeDelta=FBXSDK_TIME_ZERO);
+
+	/** Do a complete manipulation action in a single operation. This is the equivalent of calling Begin, Notify and End successively.
+	* \param pAction The action performed for this manipulation scope.
+	* \param pX Horizontal position of the manipulation, in pixels.
+	* \param pY Vertical position of the manipulation, in pixels.
+	* \param pScale Scaling value of the manipulation. Only used by eFreePan action. */
+	void Action(EAction pAction, float pX, float pY, float pScale=0);
+
+	/** Retrieve current manipulation action.
+	* \return The action currently performed by the camera manipulator. */
+	EAction GetCurrentAction() const;
+
+	/** Change camera position and LookAt node to frame all objects.
+	* \param pTime Time to use to evaluate mesh deformations. Leave at default value to cancel mesh evaluation. */
+	void FrameAll(const FbxTime& pTime=FBXSDK_TIME_INFINITE);
+
+	/** Change camera position and LookAt to frame all selected objects.
+	* \param pTime Time to use to evaluate mesh deformations. Leave at default value to cancel mesh evaluation. */
+	void FrameSelected(const FbxTime& pTime=FBXSDK_TIME_INFINITE);
+
+	/** Change camera position and LookAt to frame the selected position on screen. The LookAt will be placed
+	* at first closest intersecting geometry, and the distance between camera and LookAt will be preserved.
+	* \param pX The horizontal screen coordinate.
+	* \param pY The vertical screen coordinate.
+	* \param pCulling If \c true, only test triangles that are front-facing, otherwise test both sides.
+	* \param pTime Time to use to evaluate mesh deformations. Leave at default value to cancel mesh evaluation. */
+	void FrameScreenPosition(float pX, float pY, bool pCulling=false, const FbxTime& pTime=FBXSDK_TIME_INFINITE);
+
+	/** The camera controlled by the manipulator. */
+	FbxPropertyT<FbxReference> Camera;
+
+	/** Width of the camera viewport, in pixels. This is used to accurately calculate to movement speed.
+	* \remark If this property is not correctly set, movements will be erronous. */
+	FbxPropertyT<FbxFloat> ViewportWidth;
+
+	/** Height of the camera viewport, in pixels. This is used to accurately calculate to movement speed.
+	* \remark If this property is not correctly set, movements will be erronous. */
+	FbxPropertyT<FbxFloat> ViewportHeight;
+
+	/** Camera manipulations will be smooth if enabled. True by default. */
+	FbxPropertyT<FbxBool> Smooth;
+
+	/** Camera manipulations smoothing speed. Higher speed will stabilize the camera more quickly. Default is 10.0 */
+	FbxPropertyT<FbxDouble> SmoothSpeed;
+
+	/** Invert the camera horizontal manipulation direction if set to true. False by default. */
+	FbxPropertyT<FbxBool> InvertX;
+
+	/** Invert the camera vertical manipulation direction if set to true. False by default. */
+	FbxPropertyT<FbxBool> InvertY;
+
+	/** Restore the camera transform upon destruction of the manipulator. */
+	FbxPropertyT<FbxBool> Restore;
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+protected:
+	virtual void Construct(const FbxObject* pFrom);
+	virtual void Destruct(bool pRecursive);
+	virtual void ConstructProperties(bool pForceSet);
+	virtual bool ConnectNotify(const FbxConnectEvent& pEvent);
+	virtual bool PropertyNotify(EPropertyNotifyType pType, FbxProperty& pProperty);
+
+private:
+	void		Reset();
+	FbxCamera*	GetCamera() const;
+	FbxNode*	GetCameraNode() const;
+	FbxNode*	GetCameraLookAtNode() const;
+	FbxNode*	GetCameraTargetUpNode() const;
+	FbxVector4	GetCameraPosition() const;
+	void		SetCameraPosition(const FbxVector4& pPosition);
+	FbxVector4	GetCameraRotation() const;
+	void		SetCameraRotation(const FbxVector4& pRotation);
+	FbxVector4	GetCameraLookAtPosition() const;
+	void		SetCameraLookAtPosition(const FbxVector4& pPosition);
+	FbxVector4	GetCameraTargetUpPosition() const;
+	void		SetCameraTargetUpPosition(const FbxVector4& pPosition);
+	FbxAMatrix	GetCameraRotationMatrix() const;
+	void		SetCameraRotationMatrix(const FbxAMatrix& pRM);
+
+	double		ComputeRotationAxis(FbxVector4& pFront, FbxVector4& pUp, FbxVector4& pRight, const FbxVector4& pEye, const FbxVector4& pLookAt, const FbxVector4& pUpVector) const;
+	void		ComputeRotationMatrix(FbxAMatrix& pRM, const FbxVector4& pEye, const FbxVector4& pLookAt, const FbxVector4& pUpVector);
+	void		UpdateCameraRotation();
+
+	bool		FrameObjects(bool pSelected, const FbxTime& pTime);
+	FbxVector4	ComputePositionToFitBBoxInFrustum(const FbxVector4& pBBoxMin, const FbxVector4& pBBoxMax, const FbxVector4& pBBoxCenter, const FbxVector4& pCameraPosition, const FbxAMatrix& pCameraRM, const FbxTime& pTime);
+
+	EAction		mCurrentAction;
+	FbxFloat	mBeginMouse[3], mLastMouse[3];
+	FbxVector4	mBeginPosition, mBeginAxis[3];
+	FbxBool		mBeginFlipped;
+
+	FbxDouble	mDestOrthoZoom;
+	FbxVector4	mDestPosition, mDestLookAt, mDestTargetUp;
+	FbxAMatrix	mDestRotation;
+
+  	FbxVector4	mInitialPosition, mInitialRotation, mInitialLookAt;
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_UTILS_MANIPULATORS_H_ */

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/utils/fbxnamehandler.h

@@ -0,0 +1,143 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxnamehandler.h
+#ifndef _FBXSDK_UTILS_NAMEHANDLER_H_
+#define _FBXSDK_UTILS_NAMEHANDLER_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/core/base/fbxarray.h>
+#include <fbxsdk/core/base/fbxstring.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+/** A name is a case-sensitive string ID of a property, a node, a node attribute, a texture, etc. The characters constituting a name has no specific limitation.
+  * An initial name is the original name (from importing a file, for example), which is saved up for reversible renaming.
+  * A current name is the name used in FBX.
+  * A namespace is a simple grouping of objects under a given name. Namespaces are primarily used to resolve
+  * name-clash issues in FBX, where a new object has the same name as an existing object.
+  *
+  * For example, Maya only accepts names with letters, digits, or underscores. And when a user import FBX into Maya,
+  * a node whose name contains whitespace will be renamed. But the connections and references to this node in FBX
+  * scene graph still use the original name, so users have to use the initial name to retrieve related information.
+  * \nosubgrouping
+  */
+class FBXSDK_DLL FbxNameHandler
+{
+public:
+    /** Constructor.
+      * \param pInitialName Name string used to initialize both members (initialName and currentName)
+      * of this class.
+      */
+    FbxNameHandler(const char* pInitialName = "");
+
+    /** Copy constructor.
+      * \param pName A FbxNameHandler copied to this one.
+      */
+    FbxNameHandler(FbxNameHandler const& pName);
+
+    // !Destructor
+    ~FbxNameHandler();
+
+    /** Set the initial name.
+      * \param pInitialName New string for the initial name.
+      * \remarks The current name will also be changed to this value.
+      */
+    void SetInitialName(const char* pInitialName);
+
+    /** Get the initial name.
+      * \return Pointer to the InitialName string buffer.
+      */
+    const char* GetInitialName() const;
+
+    /** Set the current name.
+      * \param pNewName New string for the current name.
+      * \remarks The initial name is not affected.
+      */
+    void SetCurrentName(const char* pNewName);
+
+    /** Get the current name.
+      * \return Pointer to the CurrentName string buffer.
+      */
+    const char* GetCurrentName() const;
+
+    /** Set the namespace.
+      * \param pNameSpace New string for the namespace.
+      * \remarks The initial name is not affected.
+      */
+    void SetNameSpace(const char* pNameSpace);
+
+    /** Get the namespace.
+      * \return Pointer to the namespace string buffer.
+      */
+    const char* GetNameSpace() const;
+
+    /** Check if the current name and initial name match.
+      * \return \c true if the current name isn't identical to the initial name.
+      */
+    bool IsRenamed() const;
+    
+    /** Assignment operator
+      * \param pName FbxNameHandler assigned to this one.
+      */
+    FbxNameHandler& operator= (FbxNameHandler const& pName);
+
+    /**
+    * \name Private use for the renaming strategies classes.
+    *
+    * Some renaming strategies classes need to store the parent name to successfully apply the renaming algorithms. 
+    * The methods in this section allow them to do so.
+    * \remark Because of the very specific use of the mParentName string, 
+    * callers of the FbxNameHandler class should never assume that mParentName is correctly initialized 
+    * nor contains a meaningful value outside the scope of the renaming strategy class that used it.
+    */
+    //@{
+
+    /** Set the parent name.
+    * \param pParentName New string for the parent name.
+    * \remarks The parent name here could combine several hierarchy name.
+    * The full name should be "ParentName + CurrentName".
+    *   A
+    *   |_B
+    *     |_C
+    * For the above hierarchy, the parent name of C is "AB".
+    * The full name of C is "ABC".
+    */
+    void SetParentName(const char* pParentName);
+
+    /** Get the parent name.
+    * \return Pointer to the ParentName string buffer.
+    */
+    const char* GetParentName() const;
+
+    //@}
+
+    /** Get the namespaces in a string pointer array format.
+    * \return FbxArray<FbxString*> .
+    */
+    FbxArray<FbxString*> GetNameSpaceArray(char identifier);
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+    FbxString mParentName;
+    FbxString mInitialName;
+    FbxString mCurrentName;
+    FbxString mNameSpace;
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_UTILS_NAMEHANDLER_H_ */

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/utils/fbxprocessorxref.h

@@ -0,0 +1,147 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxprocessorxref.h
+#ifndef _FBXSDK_UTILS_PROCESSOR_XREF_H_
+#define _FBXSDK_UTILS_PROCESSOR_XREF_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/core/base/fbxmap.h>
+#include <fbxsdk/utils/fbxprocessor.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+/** This class contains objects
+  * This class also provides access to global settings and take information.
+  */
+class FBXSDK_DLL FbxProcessorXRefCopy : public FbxProcessor
+{
+    FBXSDK_OBJECT_DECLARE(FbxProcessorXRefCopy, FbxProcessor);
+
+public:
+    class FBXSDK_DLL MissingUrlHandler
+    {
+    public:
+        virtual ~MissingUrlHandler();
+        virtual void MissingUrl(const FbxString& pUrl, const FbxProperty&) = 0;
+    };
+
+    /**
+    * \name Properties
+    */
+    //@{
+        FbxPropertyT<FbxString>    OutputDirectory;
+
+        /** As we resolve xref and copy assets, do we update properties to
+          * now use this relative path?  Defaults to TRUE.
+          */
+        FbxPropertyT<FbxBool>     UpdateProperties;
+
+        /** Default to FALSE -- when set, this informs the processor to track
+          * every properties that were modified during the scene processing.
+          */
+        FbxPropertyT<FbxBool>     TrackUpdatedProperties;
+
+        /** Default to TRUE -- when not set, files are only copied if one of
+          * the following conditions is met:
+          * 
+          * 1) Target does not exist
+          * 2) Target has a different time
+          * 3) Target has a different size
+          */
+        FbxPropertyT<FbxBool>     ForceCopy;
+
+        /** Default to TRUE -- when copying a file, also copy its modification
+          * time.  A bit of a requirement if you're not going to use ForceCopy.
+          */
+        FbxPropertyT<FbxBool>     CopyFileTimes;
+    //@}
+
+        /** Optional callback; when set, this will be called when an Url cannot be
+          * be copied because the source is not found.
+          * Memory is owned by the client code, and will not be freed by us.
+          */
+        MissingUrlHandler*          MissingUrlHandler;
+
+    /** Since FbxProperty is an opaque type, we can't do an efficient operator <
+      * on it, and must keep the data on the object, which can be compared through
+      * pointers, and then we can further compare against the property name.
+      */
+    struct PropertyUpdate
+    {
+        FbxProperty mProperty;
+        FbxString    mOriginalValue;
+
+        inline PropertyUpdate() {}
+        inline PropertyUpdate(const FbxProperty& pProp, const FbxString& pVal) :
+            mProperty(pProp), mOriginalValue(pVal) {}
+
+        inline bool operator <(const PropertyUpdate& pOther) const
+        {
+            return strcmp(mProperty.GetName(), pOther.mProperty.GetName()) < 0;
+        }
+    };
+    typedef FbxSet<PropertyUpdate>           UpdateSet;
+    typedef FbxMap<FbxObject*, UpdateSet>    PropertyUpdateMap;
+
+    /** All properties that were updated, with their original value.
+      * Will always be empty if TrackUpdatedProperties
+      * was not set before calling ProcessCollection/ProcessObject.
+      * NOT cleared before each processing run.
+      */
+    PropertyUpdateMap& GetUpdatedProperties();
+
+    /** If property tracking was enabled, goes through and reverts all changes
+      * to the properties.  Does not un-copy the files, naturally.
+      */
+    void RevertPropertyChanges();
+
+    /** This is just a safety net to make sure RevertPropertyChanges is called when
+      * this goes out of scope.
+      */
+    struct FBXSDK_DLL AutoRevertPropertyChanges
+    {
+        AutoRevertPropertyChanges(FbxProcessorXRefCopy* pCopy) : mXRefCopy(pCopy) {}
+        ~AutoRevertPropertyChanges()
+        {
+            if( mXRefCopy )
+                mXRefCopy->RevertPropertyChanges();
+        }
+
+        FbxProcessorXRefCopy* mXRefCopy;
+    };
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+protected:
+	virtual void Construct(const FbxObject* pFrom);
+	virtual void ConstructProperties(bool pForceSet);
+
+	PropertyUpdateMap mUpdatedProperties;
+
+	// Implements the rules specified for the ForceCopy property.
+	// Also checks the ForceCopy property.
+	bool ShouldCopyFile(const FbxString& pTarget, const FbxString& pSource) const;
+
+	virtual bool	internal_ProcessCollectionBegin (FbxCollection*     pObject);
+	virtual bool	internal_ProcessCollectionEnd   (FbxCollection*     pObject);
+	virtual bool	internal_ProcessObject          (FbxObject*     pObject);
+	bool			ProcessPathProperty(FbxProperty &pProperty);
+	virtual bool	ValidPropertyForXRefCopy(FbxObject* pObject, FbxProperty& lProperty) const;
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_UTILS_PROCESSOR_XREF_H_ */

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/utils/fbxrenamingstrategy.h

@@ -0,0 +1,360 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxrenamingstrategy.h
+#ifndef _FBXSDK_UTILS_RENAMINGSTRATEGY_H_
+#define _FBXSDK_UTILS_RENAMINGSTRATEGY_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/core/base/fbxcharptrset.h>
+#include <fbxsdk/utils/fbxnamehandler.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+class FbxScene;
+class FbxNode;
+
+/** This base class is an abstract implementation of a renaming strategy for avoiding name clashes.
+  * An implementation of a reader (FbxReader) or writer (FbxWriter) class must call a concrete implementation
+  * of "FbxRenamingStrategyInterface::Rename()" every time a name is imported or exported to avoid name clashes.
+  * Any class deriving from FbxRenamingStrategyBase must implement FbxRenamingStrategyInterface::Clear(),
+  * FbxRenamingStrategyInterface::Rename(), and FbxRenamingStrategyInterface::Clone().
+  * \nosubgrouping
+  * \see FbxNameHandler FbxRenamingStrategyNumber
+  */
+class FBXSDK_DLL FbxRenamingStrategyInterface
+{
+public:
+    //! Constructor.
+    FbxRenamingStrategyInterface();
+
+    //! Destructor.
+    virtual ~FbxRenamingStrategyInterface ();
+
+    //! Resets internal state regarding assigned names.
+    virtual void Clear() = 0;
+
+    /** Rename a name if necessary to avoid name-clash issues.
+      * \param pName The name to be renamed.
+      * \return Return \c true on success, \c false otherwise.
+      */
+    virtual bool Rename(FbxNameHandler& pName) = 0;
+
+    /** Create a dynamic renaming strategy instance of the same type as the child class.
+      * \return New instance.
+      */
+    virtual FbxRenamingStrategyInterface* Clone() = 0;
+};
+
+/** Implements a renaming strategy that resolves name clashes by adding number postfixes.
+  * For example, when there are three objects with the same names "MyObject",
+  * and they will be renamed to "MyObject", "MyObject1" and "MyObject2".
+  * \nosubgrouping
+  * \see FbxNameHandler FbxRenamingStrategyBase
+  */
+class FBXSDK_DLL FbxRenamingStrategyNumber : public FbxRenamingStrategyInterface
+{
+public:
+    //! Constructor.
+    FbxRenamingStrategyNumber();
+
+    //! Destructor.
+    virtual ~FbxRenamingStrategyNumber ();
+
+    //! Resets internal state regarding assigned names.
+    virtual void Clear();
+
+    /** Rename a name if necessary to avoid name-clash issues.
+      * \param pName The name to be renamed.
+      * \return Return \c true on success, \c false otherwise.
+      */
+    virtual bool Rename(FbxNameHandler& pName);
+
+    /** Create a dynamic renaming strategy instance of the same type as the child class.
+      * \return New instance.
+      */
+    virtual FbxRenamingStrategyInterface* Clone();
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+    struct NameCell
+    {
+        NameCell(const char* pName) :
+            mName(pName),
+            mInstanceCount(0)
+        {
+        }
+            
+        FbxString mName;
+        int mInstanceCount;
+    };
+
+    FbxArray<NameCell*> mNameArray;
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+/** The FbxRenamingStrategy object can be set to rename all the objects in a scene.
+  * It can remove name clashing, remove illegal characters, manage namespaces and manage backward compatibility.
+  * It is better to choose FbxSceneRenamer instead of this class to simplify the usage.
+  * \nosubgrouping
+  * \see FbxSceneRenamer
+  */
+class FBXSDK_DLL FbxRenamingStrategy : public FbxRenamingStrategyInterface
+{
+public:
+    /** \enum EDirection The mode describing the convention direction, from FBX format or to FBX format.
+      * - \e eToFBX        Convert to FBX format from another format.
+      * - \e eFromFBX      Convert from FBX format to another format.
+      */
+    enum EDirection
+    {
+        eToFBX,
+        eFromFBX
+    };
+
+    /** Constructor.
+      * \param pMod The mode describing the convention direction, from FBX format or to FBX format.
+      * \param pOnCreationRun
+      */
+    FbxRenamingStrategy(EDirection pMod, bool pOnCreationRun = false);
+
+    //! Destructor.
+    virtual ~FbxRenamingStrategy();
+    
+    /** Rename a name if necessary.
+      * \param pName The name to be renamed.
+      * \return Return \c true on success, \c false otherwise.
+      */
+    virtual bool Rename(FbxNameHandler& pName);
+
+    //! Resets internal state regarding assigned names.
+    virtual void Clear();
+    
+    /** Create a dynamic renaming strategy instance of the same type as the child class.
+      * \return New instance.
+      */
+    virtual FbxRenamingStrategyInterface* Clone();
+
+	/** \enum EClashType
+      * - \e eNameClashAuto
+      * - \e eNameClashType1
+      * - \e eNameClashType2
+      */
+    enum EClashType
+    {
+        eNameClashAuto,
+        eNameClashType1,
+        eNameClashType2
+    };
+
+    /** Setup the strategy to perform this algorithm
+      * \param pType 
+      */
+    void SetClashSoverType(EClashType pType);
+
+    /** Returns a name with its prefix removed.
+     * \param pName    A name containing a prefix.
+     * \return         The part of pName following the "::"
+     */
+    static char* NoPrefixName (const char* pName);
+
+    /** Returns a name with its prefix removed.
+    * \param pName    A name containing a prefix.
+    * \return         The part of pName following the "::"
+    */
+    static char* NoPrefixName (FbxString& pName);
+
+    /** Get the namespace of the last renamed object.
+     * \return     Char pointer to the namespace.
+     */
+    virtual char* GetNameSpace() { return mNameSpace.Buffer(); } 
+
+    /** Sets the current scene namespace symbol.
+     * \param pNameSpaceSymbol     namespace symbol.
+     */
+    virtual void SetInNameSpaceSymbol(FbxString pNameSpaceSymbol){mInNameSpaceSymbol = pNameSpaceSymbol;}
+    
+    /** Sets the wanted scene namespace symbol.
+     * \param pNameSpaceSymbol     namespace symbol.
+     */
+    virtual void SetOutNameSpaceSymbol(FbxString pNameSpaceSymbol){mOutNameSpaceSymbol = pNameSpaceSymbol;}    
+
+    /** Sets case sensitivity for name clashing.
+     * \param pIsCaseSensitive     Set to \c true to make the name clashing case sensitive.
+     */
+    virtual void SetCaseSensibility(bool pIsCaseSensitive){mCaseSensitive = pIsCaseSensitive ;}
+
+    /** Sets the flag for character acceptance during renaming.
+     * \param pReplaceNonAlphaNum     Set to \c true to replace illegal characters with an underscore ("_").  
+     */
+    virtual void SetReplaceNonAlphaNum(bool pReplaceNonAlphaNum){mReplaceNonAlphaNum = pReplaceNonAlphaNum;}
+
+    /** Sets the flag for first character acceptance during renaming.
+     * \param pFirstNotNum     Set to \c true to add an underscore to the name if the first character is a number.
+     */
+    virtual void SetFirstNotNum(bool pFirstNotNum){mFirstNotNum = pFirstNotNum;}
+
+    /** Recursively renames all the unparented namespaced objects (Prefix mode) starting from this node.
+     * \param pNode       Parent node.
+     * \param pIsRoot     The root node.
+     * \remarks           This function adds "_NSclash" when it encounters an unparented namespaced object.
+     */
+    virtual bool RenameUnparentNameSpace(FbxNode* pNode, bool pIsRoot = false);
+
+    /** Recursively removes all the unparented namespaced "key" starting from this node.
+     * \param pNode     Parent node.
+     * \remarks         This function removes "_NSclash" when encountered. This is the opposite from RenameUnparentNameSpace.
+     */
+    virtual bool RemoveImportNameSpaceClash(FbxNode* pNode);
+
+     /** Recursively get all the namespace starting from this node's parent.
+     * \param pNode                 Parent node.
+     * \param pNameSpaceList        output the namespace list from pNode's parent to the root node.
+     */
+    virtual void GetParentsNameSpaceList(FbxNode* pNode, FbxArray<FbxString*> &pNameSpaceList);
+
+     /** Recursively replace the namespace starting from this node to its children.
+     * \param pNode        Current node.
+     * \param OldNS        The old namespace to be replaced with the NewNs.
+     * \param NewNS        The new namespace to replace OldNs.
+     */
+    virtual bool PropagateNameSpaceChange(FbxNode* pNode, FbxString OldNS, FbxString NewNS);
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+protected:
+    virtual bool RenameToFBX(FbxNameHandler& pName);
+    virtual bool RenameFromFBX(FbxNameHandler& pName);
+    virtual FbxString& ReplaceNonAlphaNum(FbxString& pName,  const char* pReplace, bool pIgnoreNameSpace);
+
+    EDirection mMode;
+    EClashType mType;
+
+    struct NameCell
+    {
+        NameCell(const char* pName) :
+            mName(pName),
+            mInstanceCount(0)
+        {
+        }
+            
+        FbxString mName;
+        int mInstanceCount;        
+    };
+
+    FbxCharPtrSet		mStringNameArray;
+    FbxArray<NameCell*>	mExistingNsList;
+    bool				mOnCreationRun;
+    bool				mCaseSensitive;
+    bool				mReplaceNonAlphaNum;
+    bool				mFirstNotNum;
+    FbxString			mNameSpace;
+    FbxString			mInNameSpaceSymbol; //symbol identifying a name space
+    FbxString			mOutNameSpaceSymbol; 
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+/** The FbxSceneRenamer provides a way to easily rename objects in a scene without using the FbxRenamingStrategy class.
+  * FbxSceneRenamer can remove name clashing and illegal characters. It also manages namespaces.
+  *
+  * Example:
+  * Maya only accepts names with letters, digits, or underscores, and we want to convert
+  * all the names of a scene from FBX format to Maya format.
+  * \code
+  * FbxSceneRenamer lSceneRenamer(pScene);
+  * lSceneRenamer.RenameFor(FbxSceneRenamer::eFBX_TO_MAYA);
+  * \endcode
+  * \nosubgrouping
+  * \see FbxRenamingStrategy
+  */
+class FBXSDK_DLL FbxSceneRenamer
+{
+public:
+    /** Constructor
+      * \param pScene A scene which contains objects to be renamed.
+      */
+    FbxSceneRenamer(FbxScene* pScene) {mScene = pScene;};
+
+    //! Destructor.
+    virtual ~FbxSceneRenamer(){};
+
+     /** \enum ERenamingMode The Mode describing from which format to which format.
+       * - \e eNone
+       * - \e eMAYA_TO_FBX5
+       * - \e eMAYA_TO_FBX_MB75
+       * - \e eMAYA_TO_FBX_MB70
+       * - \e eFBXMB75_TO_FBXMB70
+       * - \e eFBX_TO_FBX
+       * - \e eMAYA_TO_FBX
+       * - \e eFBX_TO_MAYA
+       * - \e eLW_TO_FBX
+       * - \e eFBX_TO_LW
+       * - \e eXSI_TO_FBX
+       * - \e eFBX_TO_XSI
+       * - \e eMAX_TO_FBX
+       * - \e eFBX_TO_MAX
+       * - \e eMB_TO_FBX
+       * - \e eFBX_TO_MB
+       * - \e eDAE_TO_FBX
+       * - \e eFBX_TO_DAE
+       */
+    enum ERenamingMode
+    { 
+        eNone,
+        eMAYA_TO_FBX5,
+        eMAYA_TO_FBX_MB75,
+        eMAYA_TO_FBX_MB70,
+        eFBXMB75_TO_FBXMB70,
+        eFBX_TO_FBX,
+        eMAYA_TO_FBX,
+        eFBX_TO_MAYA,
+        eLW_TO_FBX,
+        eFBX_TO_LW,
+        eXSI_TO_FBX,
+        eFBX_TO_XSI,
+        eMAX_TO_FBX,
+        eFBX_TO_MAX,
+        eMB_TO_FBX,
+        eFBX_TO_MB,
+        eDAE_TO_FBX,
+        eFBX_TO_DAE
+    };
+
+    /** Rename the objects of the scene according the specific mode.
+      * \param pMode A mode describing from which format to which format.
+      */
+    void RenameFor(ERenamingMode pMode);
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+private:
+    void ResolveNameClashing(    bool pFromFbx, bool pIgnoreNS, bool pIsCaseSensitive,
+                                bool pReplaceNonAlphaNum, bool pFirstNotNum,
+                                FbxString pInNameSpaceSymbol, FbxString pOutNameSpaceSymbol,
+                                bool pNoUnparentNS/*for MB < 7.5*/, bool pRemoveNameSpaceClash);
+
+    FbxRenamingStrategyInterface* mNodeRenamingStrategy;
+    FbxScene* mScene;
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_UTILS_RENAMINGSTRATEGY_H_ */
+

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/utils/fbxrenamingstrategyutilities.h

@@ -0,0 +1,93 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxrenamingstrategyutilities.h
+#ifndef _FBXSDK_UTILS_RENAMINGSTRATEGY_UTILITIES_H_
+#define _FBXSDK_UTILS_RENAMINGSTRATEGY_UTILITIES_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/core/base/fbxstring.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+#define NAMECLASH1_KEY      "_ncl1_" // name (x)
+#define NAMECLASH2_KEY		"_ncl2_" // Upper/lower cases clash
+
+#define UPPERTOLOWER_KEY	"ul"
+#define LOWERTOUPPER_KEY	"lu"
+
+/** \brief This class contains a set of utilities, which are used by the FBX renaming strategy.
+* \nosubgrouping
+*/
+class FBXSDK_DLL FbxRenamingStrategyUtils
+{
+public:
+
+    /** Check if the string has non alphanumeric characters and replace them with a special string containing a prefix and 
+    * the character code. 
+    * \param pString  String to be processed. The result of the conversion is also returned in this string.
+    * \param pFirstCharMustBeAlphaOnly  This flag tells whether the first char of the string must be alpha only. Its default
+    *                                   value is \c false.
+    * \param pPermittedChars   List of non alphanumeric characters that do not require to be converted because already 
+    *                          supported by the destination application. When encountered, these characters are simply 
+    *                          skipped and left as is.
+    * \param p8bitCharsOnly When \c true, this flag tells the routine that only 8 bit coded characters can be 
+    *                       represented by the encoding format (see note below). If set to \c false, the range of supported
+    *                       character is increased and the memory usage may be less. But the routine will perform slower 
+    *                       because of the internal conversions required.
+    * \return Returns \c true if at least one character in \c pString has been encoded.
+    * \note   The encoding string depends on the value of \c p8bitCharsOnly argument. When this parameter value is \c true, 
+    *         each non-alphanumeric character is replaced with FBXASC### (where ### is the decimal code of the character). 
+    *         Inversely, when the value is \c false, each non-alphanumeric characters is replaced with FBXCHR##### (where 
+    *         ##### is the hexadecimal representation of the character code).
+    */
+    static bool EncodeNonAlpha(FbxString &pString, bool pFirstCharMustBeAlphaOnly=false, FbxString pPermittedChars="", bool p8bitCharsOnly = true);
+
+    /** Take a string that has been encoded by EncodeNonAlpha and re-extract the non-alphanumeric values.
+    * \param pString String to be processed. The result of the conversion is also returned in this string.
+    * \return Returns \c true if the \c pString argument has been decoded.
+    */
+    static bool DecodeNonAlpha(FbxString &pString);
+
+    /** This method will add the _ncl1_ with the provided pInstanceNumber to the string
+    * \param pString
+    * \param pInstanceNumber  Its default value is 0.
+    * \return Always returns true.
+    * \remarks please ALWAYS call Encode Duplicate BEFORE Encode Case Insensitive.
+    */
+    static bool EncodeDuplicate(FbxString &pString, int pInstanceNumber=0);
+
+    /** This method will remove the _ncl1_xxx from the given string
+    * \param pString
+    * \return Returns true if the pString has been modified
+    */
+    static bool DecodeDuplicate(FbxString &pString);
+
+    /** This method will compare pString and pString2, set pString to pString2 and append the ncl2 suffix to it
+    * \param pString
+    * \param pString2
+    * \return Returns true if the pString has been modified
+    * \remarks pString and pString2 must be identical except for casing.
+    */
+    static bool EncodeCaseInsensitive(FbxString &pString, const FbxString pString2);
+
+    /** This method will decode a string that has a ncl2 to it
+    * \param pString
+    * \return Returns true if the pString has been modified
+    */
+    static bool DecodeCaseInsensitive(FbxString &pString);
+
+};
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_UTILS_RENAMINGSTRATEGY_UTILITIES_H_ */

Exporters/FBX/3rdParty/Fbx2016.1/include/fbxsdk/utils/fbxrootnodeutility.h

@@ -0,0 +1,78 @@
+/****************************************************************************************
+ 
+   Copyright (C) 2015 Autodesk, Inc.
+   All rights reserved.
+ 
+   Use of this software is subject to the terms of the Autodesk license agreement
+   provided at the time of installation or download, or which otherwise accompanies
+   this software in either electronic or hard copy form.
+ 
+****************************************************************************************/
+
+//! \file fbxrootnodeutility.h
+#ifndef _FBXSDK_UTILS_ROOT_NODE_UTILITY_H_
+#define _FBXSDK_UTILS_ROOT_NODE_UTILITY_H_
+
+#include <fbxsdk/fbxsdk_def.h>
+
+#include <fbxsdk/core/fbxsystemunit.h>
+
+#include <fbxsdk/fbxsdk_nsbegin.h>
+
+class FbxScene;
+class FbxAxisSystem;
+class FbxNode;
+
+/** \brief This class collects static functions for manipulating Fbx_Root nodes. 
+  * Fbx_Root nodes were used to orient and scale scenes from other graphics applications. They have been replaced by the 
+  * conversion routines in FbxAxisSystem and FbxSystemUnit. These methods are provided for backward compatibility only 
+  * and will eventually be removed. Use the conversion routines in FbxSystemUnit and FbxAxisSystem when possible.
+  */
+class FBXSDK_DLL FbxRootNodeUtility 
+{
+public:
+	
+	static const char* sFbxRootNodePrefix;
+
+	/** This method strips the scene of all Fbx_Root nodes.
+	  * \param pScene     The scene to convert
+	  * \return           \c true if successful, \c false otherwise.
+	  * \remarks          Converts the children of any Fbx_Roots to the orientation
+	  *                   and units that the Fbx_Root transformation represented.
+	  *                   The scene should look unchanged.
+	  */
+	static bool RemoveAllFbxRoots( FbxScene* pScene );
+
+	/** Inserts an Fbx_Root node into the scene to orient the 
+	  * scene from its axis and unit systems to the specified ones.
+	  * \param pScene            The scene to convert
+	  * \param pDstAxis          Destination axis.
+	  * \param pDstUnit          Destination unit
+	  * \param pUnitOptions      Unit conversion options
+	  * 
+	  */
+	static bool InsertFbxRoot(  FbxScene* pScene, 
+								const FbxAxisSystem& pDstAxis, 
+								const FbxSystemUnit& pDstUnit,
+								const FbxSystemUnit::ConversionOptions& pUnitOptions = FbxSystemUnit::DefaultConversionOptions );
+
+	/** Check if a node is an Fbx_Root node
+	  * \param pNode     The node to query
+	  * \return          \c true if pNode is a Fbx_Root node, false otherwise
+	  */
+	static bool IsFbxRootNode(FbxNode* pNode);
+
+/*****************************************************************************************************************************
+** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
+*****************************************************************************************************************************/
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+protected:
+	FbxRootNodeUtility(); 
+	FbxRootNodeUtility(const FbxRootNodeUtility& pOther); 
+	~FbxRootNodeUtility();
+#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
+};
+
+#include <fbxsdk/fbxsdk_nsend.h>
+
+#endif /* _FBXSDK_UTILS_ROOT_NODE_UTILITY_H_ */