fbsdk/fbdata.h Source File

fbdata.h
Go to the documentation of this file.
1 #ifndef __FBDATA_H__
2 #define __FBDATA_H__
3 /**************************************************************************
4 Copyright (c) 1994 - 2009 Autodesk, Inc. and/or its licensors.
5 All Rights Reserved.
6 
7 The coded instructions, statements, computer programs, and/or related
8 material (collectively the "Data") in these files contain unpublished
9 information proprietary to Autodesk, Inc. and/or its licensors, which is
10 protected by Canada and United States of America federal copyright law
11 and by international treaties.
12 
13 The Data may not be disclosed or distributed to third parties, in whole
14 or in part, without the prior written consent of Autodesk, Inc.
15 ("Autodesk").
16 
17 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
18 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
19 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR
20 ARISING BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES
21 OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
22 PURPOSE OR USE. WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT
23 WARRANT THAT THE OPERATION OF THE DATA WILL BE UNINTERRUPTED OR ERROR
24 FREE.
25 
26 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
27 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR
28 EXPENSES OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE
29 DAMAGES OR OTHER SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS
30 OF PROFITS, REVENUE OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR
31 DAMAGES OF ANY KIND), HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF
32 LIABILITY, WHETHER DERIVED FROM CONTRACT, TORT (INCLUDING, BUT NOT
33 LIMITED TO, NEGLIGENCE), OR OTHERWISE, ARISING OUT OF OR RELATING TO THE
34 DATA OR ITS USE OR ANY OTHER PERFORMANCE, WHETHER OR NOT AUTODESK HAS
35 BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE.
36 
37 **************************************************************************/
38 
45 #include <kaydaradef.h>
46 #ifndef FBSDK_DLL
47 
50  #define FBSDK_DLL K_DLLIMPORT
51 #endif
52 
53 #include <fbsdk/fbcomponent.h>
54 
55 #include <fbxsdk/fbxsdk_nsbegin.h>
56  class FbxAnimCurveNode;
57  class FbxScene;
58  class FbxAnimStack;
59  class FbxProperty;
60  class FbxObject;
61 #include <fbxsdk/fbxsdk_nsend.h>
62 
64 // Basic types
66 #define ANIMATIONNODE_TYPE_NUMBER "Number"
67 #define ANIMATIONNODE_TYPE_TIME "Time"
68 #define ANIMATIONNODE_TYPE_TIMECODE "TimeCode"
69 #define ANIMATIONNODE_TYPE_VECTOR "Vector"
70 #define ANIMATIONNODE_TYPE_VECTOR_4 "Vector4"
71 #define ANIMATIONNODE_TYPE_OBJECT "Object"
72 #define ANIMATIONNODE_TYPE_REFERENCE "Reference"
73 #define ANIMATIONNODE_TYPE_EVENT "Event"
74 #define ANIMATIONNODE_TYPE_STRING "String"
75 
76 // Types which are numbers
77 #define ANIMATIONNODE_TYPE_ACTION "Action"
78 #define ANIMATIONNODE_TYPE_BOOL "Bool"
79 #define ANIMATIONNODE_TYPE_ENUM "Enum"
80 #define ANIMATIONNODE_TYPE_INTEGER "Integer"
81 #define ANIMATIONNODE_TYPE_OCCLUSION "Occlusion"
82 #define ANIMATIONNODE_TYPE_FIELDOFVIEWX "FieldOfViewX"
83 #define ANIMATIONNODE_TYPE_FIELDOFVIEWY "FieldOfViewY"
84 #define ANIMATIONNODE_TYPE_OPTICALCENTERX "OpticalCenterX"
85 #define ANIMATIONNODE_TYPE_OPTICALCENTERY "OpticalCenterY"
86 #define ANIMATIONNODE_TYPE_IKREACHTRANSLATION "IK Reach Translation"
87 #define ANIMATIONNODE_TYPE_IKREACHROTATION "IK Reach Rotation"
88 
89 // Types which are vectors (3 members)
90 #define ANIMATIONNODE_TYPE_COLOR "Color"
91 #define ANIMATIONNODE_TYPE_LOCAL_TRANSLATION "Lcl Translation"
92 #define ANIMATIONNODE_TYPE_LOCAL_ROTATION "Lcl Rotation"
93 #define ANIMATIONNODE_TYPE_LOCAL_SCALING "Lcl Scaling"
94 #define ANIMATIONNODE_TYPE_TRANSLATION "Translation"
95 #define ANIMATIONNODE_TYPE_ROTATION "Rotation"
96 #define ANIMATIONNODE_TYPE_SCALING "Scaling"
97 
98 // Types which are vectors (4 members)
99 #define ANIMATIONNODE_TYPE_COLOR_RGBA "ColorAndAlpha"
100 
102 
103 class KFCurve;
104 
105 #include <fbxsdk/fbxsdk_nsbegin.h>
106  class FbxAnimCurve;
107 #include <fbxsdk/fbxsdk_nsend.h>
108 
109 #ifdef FBSDKUseNamespace
110 namespace FBSDKNamespace {
111 #endif
112 
113  FB_FORWARD( FBEvaluateInfo );
114  FB_FORWARD( FBPlotOptions );
115 
124  };
125  FB_DEFINE_ENUM( FBSDK_DLL, Interpolation );
126 
138  };
139 
150  };
151  FB_DEFINE_ENUM( FBSDK_DLL, TangentMode );
152 
159  //Add other clamping methods here...
160  };
161  FB_DEFINE_ENUM( FBSDK_DLL, TangentClampMode );
162 
169  };
170  FB_DEFINE_ENUM( FBSDK_DLL, TangentConstantMode );
171 
181  };
182  FB_DEFINE_ENUM( FBSDK_DLL, ExtrapolationMode );
183 
192  };
193  FB_DEFINE_ENUM( FBSDK_DLL, AnimationNodeConnectorType );
194 
202  };
203  FB_DEFINE_ENUM( FBSDK_DLL, TangentCustomIndex );
204 
213  };
214  FB_DEFINE_ENUM( FBSDK_DLL, TangentWeightMode );
215 
217  // FBFCurveKey
219  FB_FORWARD( FBFCurve );
222 
225  {
226  private:
227  DataFBFCurveKey* mLocalPtr;
228  void FBFCurveKeyInitProperties();
230  void PropertyAdd( FBProperty* ) {};
231  public:
236  FBFCurveKey( ::KFCurve* pFCurve=NULL, int pKeyIndex=1 );
237 
241  FBFCurveKey( const FBFCurveKey &pFCurveKey );
242 
245  ~FBFCurveKey();
246 
252  bool operator==(const FBFCurveKey &pValue) const;
253 
254  // To convert the derivative values to degrees (as shown in Exact mode):
255  // degrees( atan( RightDerivative ))
256  // -1 * degrees( atan( LeftDerivative ))
257  //
258  // To convert from the exact degree in Exact mode in the GUI to the corresponding
259  // derivative:
260  // tan( radians( RightDerivative ))
261  // tan( radians( -1 * LeftDerivative ))
269 
270  // TCB
274 
284 
287 
288  friend class FBFCurve;
290  };
291 
293  // FBPropertyListFCurveKey
296 
299  {
300  private:
306  virtual int Add ( FBFCurveKey pItem );
307 
313  virtual int Remove ( FBFCurveKey pItem );
314 
315  public:
316 
320  virtual void RemoveAt( int pIndex );
321 
326  virtual FBFCurveKey operator[](int pIndex);
327 
331  virtual int GetCount();
332  };
333 
335  // FBFCurve
338 
340  class FBSDK_DLL FBFCurve : public FBComponent {
342  public:
346  FBFCurve(HIObject pObject=NULL);
347 
350  virtual void FBDelete() override;
351 
356  float Evaluate(FBTime &pTime);
357 
361  void EditBegin(int pKeyCount=-1);
362 
366  void EditEnd(int pKeyCount=-1);
367 
369  void EditClear();
370 
380  int KeyAdd( FBTime &pTime, double pValue, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto );
381 
386  bool KeyRemove( int pIndex );
387 
394  bool KeyDelete( int pStartIndex, int pStopIndex );
395 
403  bool KeyDelete( FBTime pStart = FBTime::MinusInfinity, FBTime pStop = FBTime::Infinity, bool pInclusive = false );
404 
410  void KeyInsert( FBTime &pTime, FBInterpolation pInterpolation = kFBInterpolationCubic, FBTangentMode pTangentMode = kFBTangentModeAuto );
411 
419  void KeyReplaceBy( FBFCurve& pSource, FBTime pStart = FBTime::MinusInfinity, FBTime pStop = FBTime::Infinity, bool pUseExactGivenSpan = false, bool pKeyStartEndOnNoKey = true );
420 
428  bool KeyOffset(
429  FBTime& pOffsetTime,
430  int pStartIndex,
431  int pStopIndex );
432 
441  bool KeyOffset(
442  FBTime& pOffsetTime,
443  FBTime pStartTime = FBTime::MinusInfinity,
444  FBTime pStopTime = FBTime::Infinity,
445  bool pInclusive = true );
446 
450  static FBFCurve* CreateInterpolatorCurve( FBInterpolatorCurveType pCurveType );
451 
454  FBExtrapolationMode GetPostExtrapolationMode();
455 
458  void SetPostExtrapolationMode(FBExtrapolationMode pExtrapolationMode);
459 
462  int GetPostExtrapolationCount();
463 
466  void SetPostExtrapolationCount(int pCount);
467 
470  FBExtrapolationMode GetPreExtrapolationMode();
471 
474  void SetPreExtrapolationMode(FBExtrapolationMode pExtrapolationMode);
475 
478  int GetPreExtrapolationCount();
479 
482  void SetPreExtrapolationCount(int pCount);
483 
484  FBPropertyListFCurveKey GetKeys(){ return Keys; };
485  void SetKeys(FBPropertyListFCurveKey pKeys){ Keys = pKeys; };
487 
492  float KeyGetValue(int pIndex);
493 
498  void KeySetValue(int pIndex, float pValue);
499 
504  float KeyGetLeftDerivative(int pIndex);
505 
510  void KeySetLeftDerivative(int pIndex, float pValue);
511 
516  float KeyGetRightDerivative(int pIndex);
517 
522  void KeySetRightDerivative(int pIndex, float pValue);
523 
528  float KeyGetLeftTangentWeight(int pIndex);
529 
534  void KeySetLeftTangentWeight(int pIndex, float pValue);
535 
540  float KeyGetRightTangentWeight(int pIndex);
541 
546  void KeySetRightTangentWeight(int pIndex, float pValue);
547 
552  float KeyGetLeftBezierTangent(int pIndex);
553 
558  void KeySetLeftBezierTangent(int pIndex, float pValue);
559 
564  float KeyGetRightBezierTangent(int pIndex);
565 
570  void KeySetRightBezierTangent(int pIndex, float pValue);
571 
576  float KeyGetTCBTension(int pIndex);
577 
582  void KeySetTCBTension(int pIndex, float pValue);
583 
588  float KeyGetTCBContinuity(int pIndex);
589 
594  void KeySetTCBContinuity(int pIndex, float pValue);
595 
600  float KeyGetTCBBias(int pIndex);
601 
606  void KeySetTCBBias(int pIndex, float pValue);
607 
612  FBTime KeyGetTime(int pIndex);
613 
618  void KeySetTime(int pIndex, FBTime pValue);
619 
624  FBInterpolation KeyGetInterpolation(int pIndex);
625 
630  void KeySetInterpolation(int pIndex, FBInterpolation pValue);
631 
636  FBTangentMode KeyGetTangentMode(int pIndex);
637 
642  void KeySetTangentMode(int pIndex, FBTangentMode pValue);
643 
648  FBTangentClampMode KeyGetTangentClampMode(int pIndex);
649 
654  void KeySetTangentClampMode(int pIndex, FBTangentClampMode pValue);
655 
660  bool KeyGetTangentBreak(int pIndex);
661 
666  void KeySetTangentBreak(int pIndex, bool pValue);
667 
672  FBTangentConstantMode KeyGetTangentConstantMode(int pIndex);
673 
678  void KeySetTangentConstantMode(int pIndex, FBTangentConstantMode pValue);
679 
684  FBTangentCustomIndex KeyGetTangentCustomIndex(int pIndex);
685 
690  void KeySetTangentCustomIndex(int pIndex, FBTangentCustomIndex pValue);
691 
696  FBTangentWeightMode KeyGetTangentWeightMode(int pIndex);
697 
702  void KeySetTangentWeightMode(int pIndex, FBTangentWeightMode pValue);
703 
708  bool KeyGetSelected(int pIndex);
709 
715  bool KeySetSelected(int pIndex, bool pValue);
716 
721  bool KeyGetMarkedForManipulation(int pIndex);
722 
728  bool KeySetMarkedForManipulation(int pIndex, bool pValue);
729  };
730 
732 
734  // FBFCurveCustomTangent
737 
741  public:
746 
749  virtual void FBDelete() override;
750 
754  };
755 
757 
761  {
762  public:
765 
770  FBFCurveCustomTangent* operator[](int pIndex);
771  };
772 
774  // FBPropertyListAnimationNode
778  FB_DEFINE_LIST( FBSDK_DLL, AnimationNode );
779 
781  class FBSDK_DLL FBPropertyListAnimationNode : public FBPropertyBaseList< FBAnimationNode* >
782  {
783  public:
788  virtual int Add ( FBAnimationNode* pItem );
793  virtual int Remove ( FBAnimationNode* pItem );
797  virtual void RemoveAt( int pIndex );
802  virtual FBAnimationNode* operator[](int pIndex);
806  virtual int GetCount();
812  FBAnimationNode* Find( FBBox *pOriginalOwner, const char* pDataType );
817  FBAnimationNode* Find( const char* pNodeName );
822  FBAnimationNode* FindByLabel( const char* pNodeLabel );
823  };
824 
826  // FBEventAnimationNode
829 
835  };
836 
837  FB_DEFINE_ENUM( FBSDK_DLL, EventAnimationNodeType );
838 
840 
848  {
849  public:
854 
856  };
857 
859  // FBCurveEvaluationEvent
862 
865  {
866  public:
872 
876  FBXSDK_NAMESPACE::FbxAnimCurve* GetFBXCurve();
877 
882 
885  };
886 
888  // FBCurveCustomKeyAddEvent
891 
894  {
895  public:
900 
904  FBAnimationNode* GetParentAnimationNode();
905 
909  FBComponent* GetParentComponent();
910 
914  };
915 
917  // FBCurveCustomKeyChangeEvent
920 
923  {
927  };
928  FB_DEFINE_ENUM( FBSDK_DLL, CustomKeyChangeType );
929 
932  {
933  public:
938 
942  FBAnimationNode* GetParentAnimationNode();
943 
947  FBComponent* GetParentComponent();
948 
951 
955  };
956 
958  // FBPropertyEventAnimationNode
962  {
963  public:
968  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
969  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
970  };
978  typedef bool (* kFBDataHandler )(void* pBuffer,FBEvaluateInfo* pEvaluateInfo,FBAnimationNode* pAnimationNode,void* p1,void* p2);
979 
981  // FBPropertyEventAnimationNodeEvaluate
985  {
986  public:
991  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
992  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
993  };
994 
996  // FBPropertyEventAnimationNodeKeyAdd
1000  {
1001  public:
1006  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
1007  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
1008  };
1009 
1011  // FBPropertyEventAnimationNodeCustomKeyAdd
1015  {
1016  public:
1021  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
1022  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
1023  };
1024 
1026  // FBPropertyEventAnimationNodeCustomKeyChange
1030  {
1031  public:
1036  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
1037  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
1038  };
1039 
1041  // FBAnimationNode
1044  FB_DEFINE_COMPONENT( FBSDK_DLL, AnimationNode );
1045 
1047  {
1049  public:
1054  FBAnimationNode(const char *pName = NULL, HIObject pObject=NULL);
1055 
1062  void KeyAdd( const FBTime &pTime, double *pData, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto );
1063 
1069  void KeyAdd( double *pData, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto );
1070 
1075  bool SetCandidate( double* Data, bool pCheckLocked = false );
1076 
1080  void SetBufferType( bool pGlobal );
1081 
1085  void KeyCandidate( FBTime pTime = FBTime::Infinity );
1086 
1089  int GetSizeOfData();
1090 
1094  int GetDataDoubleArrayCount();
1095 
1101  bool WriteData( double* Data,FBEvaluateInfo* pEvaluateInfo );
1102 
1108  bool WriteGlobalData( double* Data,FBEvaluateInfo* pEvaluateInfo );
1109 
1116  bool ReadData( double* Data,FBEvaluateInfo* pEvaluateInfo, bool pConvertGlobalToLocal = false );
1117 
1129  bool ReadData( double *Data, FBTime pTime, bool pConvertGlobalToLocal = false );
1130 
1138  bool ReadData( double* Data );
1139 
1146  bool Evaluate( double* Data, FBTime pTime, bool pEvaluateCandidate = true );
1147 
1149  bool IsEvaluationRecursive( FBEvaluateInfo* pEvaluateInfo );
1150 
1158  void DisableIfNotWritten( FBEvaluateInfo* pEvaluateInfo );
1159 
1163  bool IsKey();
1164 
1167  void KeyRemove();
1168 
1172  void KeyRemoveAt( FBTime pTime );
1173 
1177  FBAnimationNode* GetAnimationToRecord();
1178 
1182  FBAnimationNode* GetAnimationToPlay();
1183 
1187  FBTime ConvertGlobalToNodeTime(FBTime& pKeyTime);
1188 
1192  FBTime ConvertNodeToGlobalTime(FBTime& pKeyTime);
1193 
1204 
1206 
1208 
1209  friend class FBBox;
1210  };
1211 
1213  // FBAnimationStack
1215 
1217 
1223  {
1224  //--- Open Reality declaration.
1226  public:
1227 
1232  FBAnimationStack(const char *pName, HIObject pObject=NULL);
1233 
1236  virtual void FBDelete();
1237 
1238  };
1239 
1241  // FBFCurveCustomTangentManager
1244 
1249  {
1251 
1254 
1255  public:
1256 
1263  int AddCustomTangentType(const char* pTangentName, const char* pTangentFBXName);
1264 
1270  bool RemoveCustomTangentType(const char* pTangentName);
1271 
1275  int GetCustomTangentTypeCount();
1276 
1281  const char* GetCustomTangentTypeName(int pIndex);
1282 
1284 
1287 
1289 
1293  static FBFCurveCustomTangentManager& TheOne();
1294  };
1295 
1297  // FBPropertyStateEvent
1299 
1309  };
1310  FB_DEFINE_ENUM( FBSDK_DLL, PropertyStateEventType );
1311 
1313 
1316  {
1317  public:
1322 
1326  FBProperty* GetProperty();
1327 
1331  FBComponent* GetParentComponent();
1332 
1334  };
1335 
1337  // FBFCurveEvent
1339 
1363  };
1364  FB_DEFINE_ENUM( FBSDK_DLL, FCurveEventType );
1365 
1367 
1370  {
1371  public:
1375  FBFCurveEvent( HKEventBase pEvent );
1376 
1380  FBProperty* GetParentProperty();
1381 
1385  FBAnimationNode* GetParentAnimationNode();
1386 
1390  FBComponent* GetParentComponent();
1391 
1398  };
1399 
1401  // FBPropertyChanged
1405  {
1406  public:
1411  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
1412  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
1413  };
1414 
1416  // FBFCurveChanged
1420  {
1421  public:
1426  virtual void Add ( HICallback pOwner, kICallbackHandler pHandler );
1427  virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
1428  };
1429 
1431  // FBFCurveEventManager
1434 
1439  {
1441 
1444 
1445  public:
1446 
1452  bool RegisterProperty(FBPropertyAnimatable* pProperty);
1453 
1459  bool UnregisterProperty(FBPropertyAnimatable* pProperty);
1460 
1463 
1467  static FBFCurveEventManager& TheOne();
1468  };
1469 
1471  // FBAnimationLayer
1473 
1482  };
1483  FB_DEFINE_ENUM( FBSDK_DLL, LayerMode );
1484 
1492  };
1493  FB_DEFINE_ENUM( FBSDK_DLL, LayerRotationMode );
1494 
1495 
1497 
1506  {
1507  //--- Open Reality declaration.
1509  public:
1510 
1516  FBAnimationLayer(const char *pName, int pLayerID, HIObject pObject=NULL);
1517 
1520  virtual void FBDelete();
1521 
1528 
1532  void AddChildLayer( FBAnimationLayer* pAnimationLayer );
1533 
1538  FBAnimationLayer* GetChildLayer( int pIndex );
1539 
1543  int GetChildCount();
1544 
1551  void GetCompleteChildHierarchy(FBArrayTemplate<FBAnimationLayer*>* pChildArray);
1552 
1556  void SetParentLayer(FBAnimationLayer* pParentLayer);
1557 
1561  FBAnimationLayer* GetParentLayer();
1562 
1566  int GetLayerIndex();
1567 
1572  void SelectLayer(bool pValue, bool pExclusiveSelect);
1573 
1577  bool IsSelected();
1578  };
1579 
1580 
1581  __FB_FORWARD( FBTake);
1583  // FBPropertyListTake
1585 
1589  {
1590  public:
1596  FBTake* operator[](int pIndex);
1597 
1602  virtual int Add( FBComponent* pItem ) override;
1603 
1607  virtual void RemoveAt( int pIndex ) override;
1608  };
1609 
1618  };
1619 
1625  };
1626 
1629 {
1633 };
1634 
1645 };
1646 
1648  // FBTake
1650 
1692  class FBSDK_DLL FBTake : public FBComponent {
1694  public:
1699  FBTake(const char* pName, HIObject pObject=NULL);
1700 
1705  virtual void FBDelete();
1706 
1715  FBTake* CopyTake( const char *pNewTakeName );
1716 
1719  void CreateNewLayer();
1720 
1724  void RemoveLayer(int pLayerIndex);
1725 
1730  FBAnimationLayer* GetLayer(int pLayerIndex);
1731 
1736  FBAnimationLayer* GetLayerByName(const char* pName);
1737 
1741  void SetCurrentLayer(int pLayerIndex);
1742 
1746  int GetCurrentLayer();
1747 
1751  int GetLayerCount();
1752 
1756  bool MoveCurrentLayerUp();
1757 
1761  bool MoveCurrentLayerDown();
1762 
1765  void DuplicateSelectedLayers();
1766 
1773  void MergeLayers(FBAnimationLayerMergeOptions pMergeOptions, bool pDeleteMergedLayers, FBMergeLayerMode pMergeMode, bool pMergeLockedProperties = false);
1774 
1775 // COMMENT MERGE PREIVEW
1776 #ifdef MERGE_PREVIEW
1777 
1784  bool CanDoMergePreview();
1785 
1789  bool IsInMergePreviewMode();
1790 
1794  bool DoMergePreview();
1795 
1798  void QuitMergePreview();
1799 #endif
1800 
1805  void PlotTakeOnSelected(FBPlotOptions* pPlotOptions);
1806 
1811  void PlotTakeOnSelectedProperties(FBPlotOptions* pPlotOptions);
1812 
1817  void PlotTakeOnSelected(FBTime pPlotPeriod);
1818 
1823  void PlotAllTakesOnSelected(FBTime pPlotPeriod);
1824 
1829  void PlotTakeOnSelectedProperties(FBTime pPlotPeriod);
1830 
1835  void PlotAllTakesOnSelectedProperties(FBTime pPlotPeriod);
1836 
1841  void ClearAllProperties(bool pOnSelectedObjectsOnly, bool pOnLockedProperties = false);
1842 
1845  void ClearAllPropertiesOnCurrentLayer();
1846 
1850 
1858  void PlotTakeOnObjects( FBPlotOptions* pPlotOptions, FBArrayTemplate<FBBox *> *pObjectsToPlot );
1859 
1867  void PlotTakeOnObjects( FBTime pPlotPeriod, FBArrayTemplate<FBBox *> *pObjectsToPlot );
1868 
1876  void PlotAllTakesOnObjects( FBTime pPlotPeriod, FBArrayTemplate<FBBox *> *pObjectsToPlot );
1877 
1883  void PlotTakeOnProperties( FBTime pPlotPeriod, FBArrayTemplate<FBProperty *> *pPropertiesToPlot );
1884 
1890  void PlotAllTakesOnProperties( FBTime pPlotPeriod, FBArrayTemplate<FBProperty *> *pPropertiesToPlot );
1891 
1892 
1899  int AddTimeMark( FBTime pTime, const char* pName = NULL );
1900 
1906  bool DeleteTimeMark( int pIndex );
1907 
1910  void DeleteAllTimeMarks();
1911 
1915  int GetTimeMarkCount();
1916 
1921  FBTime GetTimeMarkTime( int pIndex );
1922 
1929  int SetTimeMarkTime( int pIndex, FBTime pTime );
1930 
1935  const char* GetTimeMarkName( int pIndex );
1936 
1942  bool SetTimeMarkName( int pIndex, const char* pName );
1943 
1948  FBTimeMarkAction GetTimeMarkAction( int pIndex );
1949 
1955  bool SetTimeMarkAction( int pIndex, FBTimeMarkAction pAction );
1956 
1961  FBColor GetTimeMarkColor( int pIndex );
1962 
1968  bool SetTimeMarkColor( int pIndex, FBColor pColor );
1969 
1977  void SetLayerRealSelection(bool pValue);
1978 
1983  bool GetLayerRealSelection();
1984 
1988  int GetNextTimeMarkIndex();
1989 
1993  int GetPreviousTimeMarkIndex();
1994 
2005  bool OffsetAnimation(
2006  FBTime& pOffsetTime,
2007  FBTime pStartTime = FBTime::MinusInfinity,
2008  FBTime pStopTime = FBTime::Infinity,
2009  bool pInclusive = true,
2010  int pLayerID = -1,
2011  bool pOnLockedProperties = false );
2012 
2024  bool OffsetAnimationOnObjects(
2025  FBArrayTemplate<FBBox*>* pObjects,
2026  FBTime& pOffsetTime,
2027  FBTime pStartTime = FBTime::MinusInfinity,
2028  FBTime pStopTime = FBTime::Infinity,
2029  bool pInclusive = true,
2030  int pLayerID = -1,
2031  bool pOnLockedProperties = false );
2032 
2045  bool OffsetAnimationOnProperties(
2046  FBArrayTemplate<FBProperty*>* pProperties,
2047  FBTime& pOffsetTime,
2048  FBTime pStartTime = FBTime::MinusInfinity,
2049  FBTime pStopTime = FBTime::Infinity,
2050  bool pInclusive = true,
2051  int pLayerID = -1,
2052  bool pOnLockedProperties = false,
2053  FBPropertyComponents pPropertyComponents = kFBPropertyComponentAll );
2054 
2063  bool DeleteAnimation(
2064  FBTime pStartTime = FBTime::MinusInfinity,
2065  FBTime pStopTime = FBTime::Infinity,
2066  bool pInclusive = true,
2067  int pLayerID = -1,
2068  bool pOnLockedProperties = false );
2069 
2079  bool DeleteAnimationOnObjects(
2080  FBArrayTemplate<FBBox*>* pObjects,
2081  FBTime pStartTime = FBTime::MinusInfinity,
2082  FBTime pStopTime = FBTime::Infinity,
2083  bool pInclusive = true,
2084  int pLayerID = -1,
2085  bool pOnLockedProperties = false );
2086 
2097  bool DeleteAnimationOnProperties(
2098  FBArrayTemplate<FBProperty*>* pProperties,
2099  FBTime pStartTime = FBTime::MinusInfinity,
2100  FBTime pStopTime = FBTime::Infinity,
2101  bool pInclusive = true,
2102  int pLayerID = -1,
2103  bool pOnLockedProperties = false,
2104  FBPropertyComponents pPropertyComponents = kFBPropertyComponentAll );
2105  };
2106 
2108 
2110  // FBTimeWarpManager
2113 
2118  {
2120 
2121  public:
2122  typedef void (*TimeWarpChangeCallback)(void* pObject);
2123 
2128 
2129 
2132  void TimeWarpTakeChange();
2133 
2137  void TimeWarpClearTake(FBTake* pTake);
2138 
2142  void TimeWarpInitTake(FBTake* pTake);
2143 
2148  void TimeWarpCopyTake(FBTake* pDstTake, FBTake* pSrcTake );
2149 
2150 
2156  void TimeWarpAddToTake(FBTake* pTake, FBAnimationNode* pTimeWarp, int pNickNumber=0);
2157 
2162  void DestroyTimeWarpFromTake(FBTake* pTake, FBAnimationNode* pTimeWarp);
2163 
2167  void RemoveTimeWarpFromScene(FBAnimationNode* pTimeWarp);
2168 
2169 
2174  kLong GetTimeWarpCount(FBTake* pTake);
2175 
2181  FBAnimationNode* GetTimeWarpAtIndex(FBTake* pTake, kLong pIndex);
2182 
2183 
2189  int GetTimeWarpNickNumber(FBTake* pTake, FBAnimationNode* pTimeWarp);
2190 
2197  bool SetTimeWarpNickNumber(FBTake* pTake, FBAnimationNode* pTimeWarp, int pNumber);
2198 
2204  int GetTimeWarpNickNumberAtIndex(FBTake* pTake, kLong pIndex);
2205 
2211  FBAnimationNode* GetTimeWarpFromNickNumber(FBTake* pTake, int pNumber);
2212 
2217  int FindTimeWarpNickNumberGlobal(FBAnimationNode* pTimeWarp);
2218 
2219 
2226  bool ApplyTimeWarp(FBTake* pTake, FBProperty* pEvalProp, FBAnimationNode* pTimeWarp);
2227 
2232  void RemoveTimeWarp(FBTake* pTake, FBProperty* pEvalProp );
2233 
2234 
2239  void TimeWarpRegisterChangeEvent(TimeWarpChangeCallback pCallback, void* pObject);
2240 
2245  void TimeWarpUnregisterChangeEvent(TimeWarpChangeCallback pCallback, void* pObject);
2246 
2247 
2252  FBAnimationNode* TimeWarpCreateNew( const char* pName );
2253 
2254 
2260  void TimeWarpRename( FBTake* pTake, FBAnimationNode* pTimeWarp, const char* pNewName );
2261 
2268  void TimeWarpMergeCurveNode( FBTake* pTake,FBProperty* pEvalProp, FBAnimationNode* pNode, FBAnimationNode* pTimeWarpNode );
2269 
2273  static FBTimeWarpManager& TheOne();
2274  };
2275 
2285 FBSDK_DLL FBXSDK_NAMESPACE::FbxProperty FBtoFBXProperty(FBProperty* pSourceProperty, FBTake* pSourceTake, FBXSDK_NAMESPACE::FbxObject* pDestinationObject, FBXSDK_NAMESPACE::FbxScene* pDestinationScene, FBXSDK_NAMESPACE::FbxAnimStack* pDestinationStack, bool pCopyAnimation=true);
2286 
2297 FBSDK_DLL FBProperty* FBXtoFBProperty(FBXSDK_NAMESPACE::FbxProperty* pSourceProperty, FBXSDK_NAMESPACE::FbxAnimStack* pSourceStack, FBComponent* pDestinationObject, FBTake* pDestinationTake, bool pCopyAnimation=true, FBTime pLimitStart=FBTime::MinusInfinity, FBTime pLimitEnd=FBTime::Infinity);
2298 
2299 #ifdef FBSDKUseNamespace
2300 }
2301 #endif
2302 
2303 #endif
2304 
FBPropertyLayerMode LayerMode
Read Write Property: Layer mode.
Definition: fbdata.h:1526
class FBPropertyBase< kReference, kFBPT_kReference > FBPropertykReference
Property: kReference
When reaching the mark, the playback stops.
Definition: fbdata.h:1631
PropertyEvent: Base event class.
Definition: fbproperties.h:507
class FBPropertyBaseEnum< enum FBCustomKeyChangeType > FBPropertyCustomKeyChangeType
Definition: fbdata.h:928
Property: Base property class.
Definition: fbproperties.h:192
Fourth component (e.g.
Definition: fbdata.h:1640
Number of interpolation types.
Definition: fbdata.h:123
FBInterpolation
Types of interpolation for an FCurve.
Definition: fbdata.h:117
Time independent, is calculated based upon the slope between the previous and next key values...
Definition: fbdata.h:148
The animation node output connector is connected to at least one animation node input connector (vali...
Definition: fbdata.h:190
#define __FBClassDeclare(Name, Parent)
For internal use only.
Definition: fbcomponent.h:132
A key continuity was changed (only valid on TCB key)
Definition: fbdata.h:1358
FBPropertyInt LeftCustomTangentTypeIndex
Read Only Property: FbxAnimCurveOnly - Type of the left key custom tangent type, -1 if not a custom t...
Definition: fbdata.h:883
A key velocity was changed.
Definition: fbdata.h:1355
FBPropertyCustomKeyChangeType ChangeType
Read Write Property: Indicate which setting of the key was/will be changed.
Definition: fbdata.h:950
FBPropertyInt CurveIndex
Read Only Property: Index of curve.
Definition: fbdata.h:1397
FBPropertyString Comments
Read Write Property: Take comments.
Definition: fbdata.h:1849
If the layer has a weight of 75%, the precedent layers will have a combined effect of 25% on the fina...
Definition: fbdata.h:1481
KeyFrame for an FCurve.
Definition: fbdata.h:224
A box is a fundamental building block in the application architecture.
Definition: fbcore.h:218
The rotation will be computed using quaternion.
Definition: fbdata.h:1491
Right tangent and next key left tangent weight are active.
Definition: fbdata.h:212
A key tension was changed (only valid on TCB key)
Definition: fbdata.h:1357
#define FB_DEFINE_COMPONENT(DllTag, Type)
Define a component and give it the ability to be a property.
Definition: fbproperties.h:139
#define FB_DEFINE_LIST(DllTag, Type)
Define a component list.
Definition: fbproperties.h:161
FBPropertyInt KeyIndexStart
Read Only Property: Index of the first key which is involved in the event.
Definition: fbdata.h:1393
Property class: const char * (String).
Time data structure.
Definition: fbtime.h:86
PropertyEvent: Event when a key with a custom tangent that needs some of its parameters to be specifi...
Definition: fbdata.h:1014
Merge the animation of all properties of the selected models from all the layers to the BaseAnimation...
Definition: fbdata.h:1615
FBPropertyTimeSpan LocalTimeSpan
Read Write Property: Local time span.
Definition: fbdata.h:1848
FBPropertyInt CustomTangentIndex
Read Only Property: Index of the custom tangent in the system.
Definition: fbdata.h:753
Linear interpolation.
Definition: fbdata.h:120
class FBPropertyBaseEnum< enum FBLayerMode > FBPropertyLayerMode
Definition: fbdata.h:1483
FBPropertyEventAnimationNode OnChange
Event: Called when the value of this property is modified
Definition: fbdata.h:1207
Cubic interpolation.
Definition: fbdata.h:121
Like USER but left slope may differ from right.
Definition: fbdata.h:147
The transform manipulator has begun doing modifications This event occurs every time a manipulator: ...
Definition: fbdata.h:847
Custom Tangent Manager Interface to the Custom Tangent Manager.
Definition: fbdata.h:1248
Merge the animation of all properties of the selected models from the selected layers to the selected...
Definition: fbdata.h:1614
FBPropertyTangentMode TangentMode
Read Write Property: Tangent calculation method.
Definition: fbdata.h:277
bool
Definition: asdl.h:9
A key interpolation mode was changed.
Definition: fbdata.h:1350
FBPropertyTangentWeightMode TangentWeightMode
Read Write Property: Tangent's weight mode.
Definition: fbdata.h:281
Used to represent all splines with no lost data (HERMITE, BEZIER, CATMUL, etc.)
Definition: fbdata.h:146
FBPropertyPropertyStateEventType EventType
Read Only Property: Event type, please see the FBPropertyStateEventType for the possible types...
Definition: fbdata.h:1333
A take is a container for animation in a scene.
Definition: fbdata.h:1692
class FBPropertyBaseComponent< FBFCurve * > FBPropertyFCurve
Definition: fbdata.h:731
Third custom tangent type registered in the system.
Definition: fbdata.h:201
Used to access animation stack.
Definition: fbdata.h:1222
FBPropertyTime Time
Read Only Property: Time where the key will be added.
Definition: fbdata.h:912
class FBPropertyBaseEnum< enum FBTangentCustomIndex > FBPropertyTangentCustomIndex
Definition: fbdata.h:203
FBPropertyFloat LeftBezierTangent
Read Write Property: Left bezier tangent
Definition: fbdata.h:267
#define NULL
Definition: kaydara.h:179
Constant interpolation.
Definition: fbdata.h:119
FBPropertyAnimationNode Parent
Read Only Property: Parent animation node.
Definition: fbdata.h:1201
Template class to contain an array of items.
Definition: fbarray.h:77
Property connector was destroyed (property animation was deleted)
Definition: fbdata.h:1307
FBPropertyBool Selected
Read Write Property: Is the key selected.
Definition: fbdata.h:285
Tangent weight disabled.
Definition: fbdata.h:209
FBPropertyFloat RightTangentWeight
Read Write Property: Right tangent weight
Definition: fbdata.h:266
PropertyEvent: Event when a property is modified, to be used with the FBFCurveEventManager.
Definition: fbdata.h:1404
A key bias was changed (only valid on TCB key)
Definition: fbdata.h:1359
FBTangentMode
Methods of tangent calculation.
Definition: fbdata.h:143
A curve pre-extrapolation value was changed.
Definition: fbdata.h:1360
class FBPropertyBase< int, kFBPT_int > FBPropertyInt
Property: int
PropertyEvent: Event when a key that doesn't have a custom tangent is added.
Definition: fbdata.h:999
Time Warp Manager Interface to the Time Warp Manager.
Definition: fbdata.h:2117
FBFCurveEventType
This enum indicates what modification was made to a tracked FCurve.
Definition: fbdata.h:1343
Merge the animation of the selected properties of the selected models from all the layers to the Base...
Definition: fbdata.h:1613
FBPropertyTime Time
Read Write Property: Time of key.
Definition: fbdata.h:275
FBPropertyBool Mute
Read Write Property: If true, the layer is muted.
Definition: fbdata.h:1523
PropertyEvent: Event when a custom tangent that needs to be evaluated.
Definition: fbdata.h:984
FBLayerMode
Layer mode.
Definition: fbdata.h:1477
class FBPropertyBaseEnum< enum FBTangentClampMode > FBPropertyTangentClampMode
Definition: fbdata.h:161
FBTangentClampMode
Different clamping modes for the tangents.
Definition: fbdata.h:156
Color vector.
Definition: fbtypes.h:447
Property connector was detached (property animation was delete from the scene, but it still keep in c...
Definition: fbdata.h:1306
FBPropertyBool IsPreCall
Read Only Property: True before the value is actually changed (allowing you to cache the current stat...
Definition: fbdata.h:949
FBPropertyStateEventType
This enum indicates what modification was made to the animation of a tracked property.
Definition: fbdata.h:1303
FBXSDK_NAMESPACE::FbxProperty FBtoFBXProperty(FBProperty *pSourceProperty, FBTake *pSourceTake, FBXSDK_NAMESPACE::FbxObject *pDestinationObject, FBXSDK_NAMESPACE::FbxScene *pDestinationScene, FBXSDK_NAMESPACE::FbxAnimStack *pDestinationStack, bool pCopyAnimation=true)
Convert a FBProperty to a FbxProperty, useful to extract some properties to a FBX file...
Base Event class.
Definition: fbcomponent.h:955
class FBPropertyBaseEnum< enum FBExtrapolationMode > FBPropertyExtrapolationMode
Definition: fbdata.h:182
A key constant mode was changed.
Definition: fbdata.h:1354
Animatable property base class.
#define FB_DEFINE_ENUM(DllTag, Type)
Define an enum and give it the ability to be a property.
Definition: fbproperties.h:148
FBPropertyInt KeyIndexStop
Read Only Property: Index of the last key which is involved in the event.
Definition: fbdata.h:1394
This class is used when changing the interpolation type/custom tangent index of a key with a custom t...
Definition: fbdata.h:931
FBAnimationNodeConnectorType
Different types for the animation node connectors.
Definition: fbdata.h:187
Layer value will override the value of the other precedent layers.
Definition: fbdata.h:1480
Invalid interpolation.
Definition: fbdata.h:118
List of animation nodes.
Definition: fbdata.h:781
FBPropertyTangentCustomIndex TangentCustomIndex
Read Write Property: Tangent's custom index
Definition: fbdata.h:283
Merge the animation of all properties from the selected layers to the selected layer with the lowest ...
Definition: fbdata.h:1616
This class is used when adding a key with a custom tangent to a curve. It contains the necessary info...
Definition: fbdata.h:893
The animation node input connector has a constant value set to it (valid for input connector only)...
Definition: fbdata.h:191
FBPropertyEventAnimationNodeKeyAdd OnKeyAdd
Event: Called when adding a key that doesn't have a custom tangent, you can specify some of its param...
Definition: fbdata.h:1285
FBPropertyFloat RightDerivative
Read Write Property: Right derivative, in units/seconds.
Definition: fbdata.h:264
FBAnimationLayerMergeOptions
Merge option for animation layers.
Definition: fbdata.h:1611
class FBPropertyBaseEnum< enum FBTangentWeightMode > FBPropertyTangentWeightMode
Definition: fbdata.h:214
Next key left tangent weight active.
Definition: fbdata.h:211
FBPropertyFCurve Curve
Read Only Property: Curve that will receive the new key.
Definition: fbdata.h:1395
FBPropertyFloat Bias
Read Write Property: Bias (TCB).
Definition: fbdata.h:273
FBPropertyString Label
Read Write Property: Label (UI Name).
Definition: fbdata.h:1194
FBTangentCustomIndex
Custom tangent index for the tangents.
Definition: fbdata.h:198
FBPropertyFloat Value
Read Write Property: Value of Key
Definition: fbdata.h:262
Time independent, will flatten the tangent handles when the key value goes over or under the previous...
Definition: fbdata.h:149
This class is used when the state of a property tracked by the FBFCurveEventManager is changed...
Definition: fbdata.h:1315
This is the equivalent to a cardinal spline with no parametrization.
Definition: fbdata.h:144
Third component (e.g.
Definition: fbdata.h:1639
FBPropertyInterpolation DefaultInterpolation
Read Write Property: Default type of interpolation.
Definition: fbdata.h:1202
FBPropertyFloat Tension
Read Write Property: Tension (TCB).
Definition: fbdata.h:271
The tangent will contain the value of the next keyframe.
Definition: fbdata.h:168
Second custom tangent type registered in the system.
Definition: fbdata.h:200
FBExtrapolationMode
Modes for pre / post extrapolation.
Definition: fbdata.h:175
class FBPropertyBaseComponent< FBAnimationNode * > FBPropertyAnimationNode
Definition: fbdata.h:1044
The custom tangent value was/will be modified (FBTangentCustomIndex).
Definition: fbdata.h:926
FBFCurveChanged OnFCurveEvent
Event: Called when a registered FCurve is modified.
Definition: fbdata.h:1461
FBPropertyDouble KeyIndex
Read Only Property: Index of the key to evaluate, a decimal value indicates an evaluation between two...
Definition: fbdata.h:878
Definition: Python-ast.h:18
FBPropertyString CurveName
Read Only Property: Name of curve.
Definition: fbdata.h:1396
TCB spline (3 parameters: TENSION, CONTINUITY, BIAS)
Definition: fbdata.h:145
PropertyList: Concrete class for PropertyList of component
Definition: fbcomponent.h:549
void SetKeys(FBPropertyListFCurveKey pKeys)
Definition: fbdata.h:485
This class is used when an evaluation must be done on your custom tangents. It contains the necessary...
Definition: fbdata.h:864
class FBPropertyBaseEnum< enum FBAnimationNodeConnectorType > FBPropertyAnimationNodeConnectorType
Definition: fbdata.h:193
#define __FB_FORWARD(ClassName)
Forwarding of class and typedef declaration.
Definition: fbtypes.h:68
FBPropertyTime Time
Read Only Property: Time of the key.
Definition: fbdata.h:953
FBPropertyBool Solo
Read Write Property: If true, the layer is soloed.
Definition: fbdata.h:1522
PropertyEvent: UI idle event.
Definition: fbdata.h:961
This class represents a custom tangents object in the system.
Definition: fbdata.h:739
A curve post-extrapolation value was changed.
Definition: fbdata.h:1361
Option parameters for plotting.
Used to access animation layer properties and modify them.
Definition: fbdata.h:1505
First custom tangent type registered in the system.
Definition: fbdata.h:199
FBPropertyAnimationNodeConnectorType ConnectorType
Read Only Property: Animation node connector type.
Definition: fbdata.h:1203
FBPropertyFCurveEventType EventType
Read Only Property: Type of fcurve event.
Definition: fbdata.h:1392
FBLayerRotationMode
Rotation mode for layer.
Definition: fbdata.h:1488
FBPropertyDouble Result
Read Write Property: Write the resulting value in that prorperty.
Definition: fbdata.h:881
#define FBSDKNamespace
FBSDKNamespace define.
Definition: fbversion.h:64
FBCustomKeyChangeType
Indicate if the interpolation or the custom index of the key will be/was modified.
Definition: fbdata.h:922
FBTangentConstantMode
Different constant modes for the tangents.
Definition: fbdata.h:166
FBTangentWeightMode
Active tangent weight, no/one/both side are active on a key.
Definition: fbdata.h:208
The resulting layer will be in override mode if one of the source layer is in override, otherwise, it will be in additive mode.
Definition: fbdata.h:1622
FBPropertyString CustomTangentFBXName
Read Only Property: Name of custom tangent, will be used in the FBX file to identify custom key type...
Definition: fbdata.h:752
An operation affecting multiple keys was made.
Definition: fbdata.h:1362
FBPropertyFCurve Curve
Read Only Property: Curve with the key set to the custom tangent type.
Definition: fbdata.h:954
FBPropertyTimeSpan ReferenceTimeSpan
Read Write Property: Reference time span.
Definition: fbdata.h:1847
Basic class definitions.
class FBPropertyBaseEnum< enum FBFCurveEventType > FBPropertyFCurveEventType
Definition: fbdata.h:1364
FBProperty * FBXtoFBProperty(FBXSDK_NAMESPACE::FbxProperty *pSourceProperty, FBXSDK_NAMESPACE::FbxAnimStack *pSourceStack, FBComponent *pDestinationObject, FBTake *pDestinationTake, bool pCopyAnimation=true, FBTime pLimitStart=FBTime::MinusInfinity, FBTime pLimitEnd=FBTime::Infinity)
Convert a FbxProperty to a FBProperty, useful to extract some properties from a FBX file to a MotionB...
The animation node connector is not connected and doesn't have a constant value set to it...
Definition: fbdata.h:188
FBPropertyInterpolation Interpolation
Read Write Property: Type of interpolation.
Definition: fbdata.h:276
class FBPropertyBase< FBTimeSpan, kFBPT_TimeSpan > FBPropertyTimeSpan
Property: FBTimeSpan
KEventBase * HKEventBase
Definition: fbcomponent.h:75
FBPropertyEventAnimationNodeEvaluate OnEvaluate
Event: Called when evaluating the node, you must evaluate your curve and return the computed value...
Definition: fbdata.h:1283
First component (e.g.
Definition: fbdata.h:1637
The tangent will be flattened when the key is placed at the same value as an adjacent key...
Definition: fbdata.h:158
FBEventAnimationNodeType
Event based on animation node.
Definition: fbdata.h:831
FBPropertyListFCurveKey GetKeys()
Definition: fbdata.h:484
FBPropertyEventAnimationNodeCustomKeyAdd OnCustomKeyAdd
Event: Called when adding a key with a custom tangent, you must specify some of its parameters...
Definition: fbdata.h:1286
Property connector was added (can happen when undoing a delete operation, which set back the property...
Definition: fbdata.h:1305
FBPropertyBool TangentBreak
Read Write Property: Tangent's break status
Definition: fbdata.h:279
class FBPropertyBase< float, kFBPT_float > FBPropertyFloat
Property: float
MotionBuilder SDK base class.
Definition: fbcomponent.h:664
FBPropertyListAnimationNode Nodes
List: List of animation nodes.
Definition: fbdata.h:1205
bool operator==(const FBPickInfos &pLhs, const FBPickInfos &pRhs)
FBPropertyFloat LeftTangentWeight
Read Write Property: Left tangent weight
Definition: fbdata.h:265
The tangent will contain the value of the current keyframe until the next keyframe.
Definition: fbdata.h:167
#define FBSDK_DLL
Be sure that FBSDK_DLL is defined only once...
Definition: fbdata.h:50
FBPropertyFCurve FCurve
Read Write Property: FCurve for animation.
Definition: fbdata.h:1198
class FBPropertyBase< double, kFBPT_double > FBPropertyDouble
Property: double
#define FB_FORWARD(ClassName)
Forwarding of class and typedef declaration.
Definition: fbtypes.h:62
PropertyEvent: Event when a fcurve is changed.
Definition: fbdata.h:1419
The resulting layer will be in override mode, if possible.
Definition: fbdata.h:1624
FBPropertyFloat LeftDerivative
Read Write Property: Left derivative, in units/seconds.
Definition: fbdata.h:263
class FBPropertyBaseAnimatable< double, kFBPT_double > FBPropertyAnimatableDouble
FBPropertyBaseAnimatableDouble type definition.
class FBPropertyBase< FBTime, kFBPT_Time > FBPropertyTime
Property: FBTime
FBPropertyBool MarkedForManipulation
Read Write Property: Is the key marked for manipulation.
Definition: fbdata.h:286
class FBPropertyBaseEnum< enum FBLayerRotationMode > FBPropertyLayerRotationMode
Definition: fbdata.h:1493
FBPropertyTime Time
Read Only Property: Time to evaluate.
Definition: fbdata.h:879
Merge the animation of the selected properties of the selected models from the selected layers to the...
Definition: fbdata.h:1612
Custom interpolation.
Definition: fbdata.h:122
class FBPropertyBaseEnum< enum FBPropertyStateEventType > FBPropertyPropertyStateEventType
Definition: fbdata.h:1310
FCurve class.
Definition: fbdata.h:340
FBPropertyString CustomTangentName
Read Only Property: Name of custom tangent, will be displayed in the interface.
Definition: fbdata.h:751
The animation node input connector is connected to an animation node output connector (valid for inpu...
Definition: fbdata.h:189
When reaching the mark, the playback loops to previous global mark (or start frame if any)...
Definition: fbdata.h:1632
FBPropertyTangentConstantMode TangentConstantMode
Read Write Property: Tangent's constant mode
Definition: fbdata.h:280
FCurve Event Manager Interface to the FBFCurveEventManager.
Definition: fbdata.h:1438
FBPropertyInt RightCustomTangentTypeIndex
Read Only Property: FbxAnimCurveOnly - Type of the right key custom tangent type, -1 if not a custom ...
Definition: fbdata.h:884
Second component (e.g.
Definition: fbdata.h:1638
FBMergeLayerMode
Merge layer mode for animation layers. This will specify the mode of the resulting merged layer...
Definition: fbdata.h:1621
FBPropertyBool Live
Read Write Property: Is animation live?
Definition: fbdata.h:1199
class FBPropertyBaseEnum< enum FBInterpolation > FBPropertyInterpolation
Definition: fbdata.h:125
FBPropertyComponents
Property Components Bit Field (XYZ, RGB, RGBA, UV, XYZW, etc.).
Definition: fbdata.h:1636
FBPropertyInt KeyIndex
Read Only Property: Index of the key with the custom tangent type.
Definition: fbdata.h:952
class FBPropertyBaseEnum< enum FBTangentConstantMode > FBPropertyTangentConstantMode
Definition: fbdata.h:170
Merge the animation of all properties from all the layers to the BaseAnimation layer.
Definition: fbdata.h:1617
AnimationNodeNotify evaluation information.
const char void * pValue
Definition: fbcontrols.h:2116
List of FCurveKey.
Definition: fbdata.h:298
FBPropertyBool RecordMode
Read Write Property: Is the node in recording mode (device connectors)?
Definition: fbdata.h:1200
Property was heavily modified (switching to story tool, story clip deleted...)
Definition: fbdata.h:1308
class FBPropertyBaseEnum< enum FBTangentMode > FBPropertyTangentMode
Definition: fbdata.h:151
bool(* kFBDataHandler)(void *pBuffer, FBEvaluateInfo *pEvaluateInfo, FBAnimationNode *pAnimationNode, void *p1, void *p2)
kFBDataHandler
Definition: fbdata.h:978
FBPropertyInt KeyIndex
Read Only Property: Index of the new key that will be added
Definition: fbdata.h:911
FBTimeMarkAction
Time (Global & Take) Mark assigned action.
Definition: fbdata.h:1628
The interpolation of the key was/will be modified (FBInterpolation).
Definition: fbdata.h:925
FBInterpolatorCurveType
Types of interpolator for an FCurve.
Definition: fbdata.h:128
The rotation will be computed component by component.
Definition: fbdata.h:1490
FBPropertyLayerRotationMode LayerRotationMode
Read Only Property: Layer rotation mode.
Definition: fbdata.h:1527
The resulting layer will be in additive mode, if possible.
Definition: fbdata.h:1623
FBPropertykReference Reference
Read Write Property: User-defined reference.
Definition: fbdata.h:1196
Right tangent weight active.
Definition: fbdata.h:210
FBPropertyString UserName
Read Only Property: Name of animation node.
Definition: fbdata.h:1195
FBPropertyFloat RightBezierTangent
Read Write Property: Right bezier tangent
Definition: fbdata.h:268
class FBPropertyBaseEnum< enum FBEventAnimationNodeType > FBPropertyEventAnimationNodeType
Definition: fbdata.h:837
A key left/right/both derivative was changed, please note that this event can affect the key specifie...
Definition: fbdata.h:1349
FBPropertyEventAnimationNodeType Type
Read Only Property: Type of selection event.
Definition: fbdata.h:855
The tangent will act normally.
Definition: fbdata.h:157
FBPropertyTangentClampMode TangentClampMode
Read Write Property: Tangent's clamp method.
Definition: fbdata.h:278
This class is used when a modification is made on a FCurve. It contains the necessary information to ...
Definition: fbdata.h:1369
No change to the key.
Definition: fbdata.h:924
FBPropertyFloat Continuity
Read Write Property: Continuity (TCB).
Definition: fbdata.h:272
PropertyEvent: Event when a key tangent is changed to a custom tangent/changed to another type from a...
Definition: fbdata.h:1029
FBPropertyEventAnimationNodeCustomKeyChange OnCustomKeyChange
Event: Called when the interpolation/tangent of a key is changed to/from a custom tangent or custom t...
Definition: fbdata.h:1288
FBPropertyAnimatableDouble Weight
Read Write Property: The weight value of a layer determines how much it is present in the result anim...
Definition: fbdata.h:1525
FBPropertyInt KeyCount
Read Only Property: Number of keys.
Definition: fbdata.h:1197
Layer value will be added to the other layers to computed the final value.
Definition: fbdata.h:1479
FBPropertyFCurve Curve
Read Only Property: Curve to evaluate.
Definition: fbdata.h:880
FBPropertyChanged OnPropertyEvent
Event: Called when a registered property state is modified (detached, destroyed...).
Definition: fbdata.h:1462
void(ICallback::* kICallbackHandler)(HIRegister pCaller, HKEventBase pEvent)
Definition: icallback.h:50
FBPropertyFCurve Curve
Read Only Property: Curve that will receive the new key.
Definition: fbdata.h:913
FBPropertyExtrapolationMode ExtrapolationMode
Read Write Property: Extrapolation mode
Definition: fbdata.h:282
A key left/right weight was changed, please note that this event can affect the key specified in the ...
Definition: fbdata.h:1356
class FBPropertyBase< bool, kFBPT_bool > FBPropertyBool
Property: bool
FBPropertyBool Lock
Read Write Property: If true, the layer is locked.
Definition: fbdata.h:1524