Open Reality Reference Guide
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 
115 
124  };
125  FB_DEFINE_ENUM( FBSDK_DLL, Interpolation );
126 
129  kFBInterpolatorCurveLinearIn,
130  kFBInterpolatorCurveLinearOut,
131  kFBInterpolatorCurveSmoothIn,
132  kFBInterpolatorCurveSmoothOut,
133  kFBInterpolatorCurveSlowIn,
134  kFBInterpolatorCurveSlowOut,
135  kFBInterpolatorCurveFastIn,
136  kFBInterpolatorCurveFastOut,
137  kFBInterpolatorCurveLast
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 
176  kFCurveExtrapolationConst = 1,
177  kFCurveExtrapolationRepetition = 2,
178  kFCurveExtrapolationMirrorRepetition = 3,
179  kFCurveExtrapolationKeepSlope = 4,
180  kFCurveExtrapolationRelativeRepetition = 5
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 
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 
276  FBPropertyInterpolation Interpolation;
277  FBPropertyTangentMode TangentMode;
278  FBPropertyTangentClampMode TangentClampMode;
280  FBPropertyTangentConstantMode TangentConstantMode;
281  FBPropertyTangentWeightMode TangentWeightMode;
282  FBPropertyExtrapolationMode ExtrapolationMode;
283  FBPropertyTangentCustomIndex TangentCustomIndex;
284 
287 
288  friend class FBFCurve;
289  friend class FBPropertyListFCurveKey;
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 
451 
455 
459 
463 
466  void SetPostExtrapolationCount(int pCount);
467 
471 
475 
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 
625 
630  void KeySetInterpolation(int pIndex, FBInterpolation pValue);
631 
637 
642  void KeySetTangentMode(int pIndex, FBTangentMode pValue);
643 
649 
654  void KeySetTangentClampMode(int pIndex, FBTangentClampMode pValue);
655 
660  bool KeyGetTangentBreak(int pIndex);
661 
666  void KeySetTangentBreak(int pIndex, bool pValue);
667 
673 
679 
685 
691 
697 
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 
731  FB_DEFINE_COMPONENT( FBSDK_DLL, FCurve );
732 
734  // FBFCurveCustomTangent
737 
741  public:
745  FBFCurveCustomTangent(HIObject pObject=NULL);
746 
749  virtual void FBDelete() override;
750 
754  };
755 
757 
761  {
762  public:
765 
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 
832  kFBEventAnimationNodeDataChange,
833  kFBEventAnimationNodeConstraintChange,
834  kFBEventAnimationNodeNone
835  };
836 
837  FB_DEFINE_ENUM( FBSDK_DLL, EventAnimationNodeType );
838 
840 
848  {
849  public:
853  FBEventAnimationNode( HKEventBase pEvent );
854 
855  FBPropertyEventAnimationNodeType Type;
856  };
857 
859  // FBCurveEvaluationEvent
862 
865  {
866  public:
871  FBCurveEvaluationEvent( HKEventBase pEvent );
872 
876  FBXSDK_NAMESPACE::FbxAnimCurve* GetFBXCurve();
877 
880  FBPropertyFCurve Curve;
882 
885  };
886 
888  // FBCurveCustomKeyAddEvent
891 
894  {
895  public:
899  FBCurveCustomKeyAddEvent( HKEventBase pEvent );
900 
905 
910 
913  FBPropertyFCurve Curve;
914  };
915 
917  // FBCurveCustomKeyChangeEvent
920 
923  {
927  };
928  FB_DEFINE_ENUM( FBSDK_DLL, CustomKeyChangeType );
929 
932  {
933  public:
937  FBCurveCustomKeyChangeEvent( HKEventBase pEvent );
938 
943 
948 
950  FBPropertyCustomKeyChangeType ChangeType;
951 
954  FBPropertyFCurve Curve;
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 
1086 
1090 
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 
1178 
1183 
1188 
1193 
1198  FBPropertyFCurve FCurve;
1201  FBPropertyAnimationNode Parent;
1202  FBPropertyInterpolation DefaultInterpolation;
1203  FBPropertyAnimationNodeConnectorType ConnectorType;
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() override;
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 
1276 
1281  const char* GetCustomTangentTypeName(int pIndex);
1282 
1284 
1287 
1289 
1294  };
1295 
1297  // FBPropertyStateEvent
1299 
1309  };
1310  FB_DEFINE_ENUM( FBSDK_DLL, PropertyStateEventType );
1311 
1313 
1316  {
1317  public:
1321  FBPropertyStateEvent( HKEventBase pEvent );
1322 
1327 
1332 
1333  FBPropertyPropertyStateEventType EventType;
1334  };
1335 
1337  // FBFCurveEvent
1339 
1363  };
1364  FB_DEFINE_ENUM( FBSDK_DLL, FCurveEventType );
1365 
1367 
1370  {
1371  public:
1375  FBFCurveEvent( HKEventBase pEvent );
1376 
1381 
1386 
1391 
1392  FBPropertyFCurveEventType EventType;
1395  FBPropertyFCurve Curve;
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 
1453 
1460 
1463 
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() override;
1521 
1526  FBPropertyLayerMode LayerMode;
1527  FBPropertyLayerRotationMode LayerRotationMode;
1528 
1532  void AddChildLayer( FBAnimationLayer* pAnimationLayer );
1533 
1539 
1544 
1552 
1556  void SetParentLayer(FBAnimationLayer* pParentLayer);
1557 
1562 
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() override;
1706 
1715  FBTake* CopyTake( const char *pNewTakeName );
1716 
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 
1747 
1752 
1757 
1762 
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 
1812 
1817  void PlotTakeOnSelected(FBTime pPlotPeriod);
1818 
1823  void PlotAllTakesOnSelected(FBTime pPlotPeriod);
1824 
1830 
1836 
1841  void ClearAllProperties(bool pOnSelectedObjectsOnly, bool pOnLockedProperties = false);
1842 
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 
1911 
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 
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 
1984 
1989 
1994 
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 
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 
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 
2064  FBTime pStartTime = FBTime::MinusInfinity,
2065  FBTime pStopTime = FBTime::Infinity,
2066  bool pInclusive = true,
2067  int pLayerID = -1,
2068  bool pOnLockedProperties = false );
2069 
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 
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 
2107  FB_DEFINE_COMPONENT( FBSDK_DLL, Take );
2108 
2110  // FBTimeWarpManager
2113 
2118  {
2120 
2121  public:
2122  typedef void (*TimeWarpChangeCallback)(void* pObject);
2123 
2128 
2129 
2133 
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 
2163 
2168 
2169 
2174  kLong GetTimeWarpCount(FBTake* pTake);
2175 
2182 
2183 
2190 
2197  bool SetTimeWarpNickNumber(FBTake* pTake, FBAnimationNode* pTimeWarp, int pNumber);
2198 
2204  int GetTimeWarpNickNumberAtIndex(FBTake* pTake, kLong pIndex);
2205 
2212 
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 
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 
FBCurveCustomKeyChangeEvent::Curve
FBPropertyFCurve Curve
Read Only Property: Curve with the key set to the custom tangent type.
Definition: fbdata.h:954
FBFCurve::KeyGetMarkedForManipulation
bool KeyGetMarkedForManipulation(int pIndex)
Get the key manipulation state.
FBFCurveKey::TangentConstantMode
FBPropertyTangentConstantMode TangentConstantMode
Read Write Property: Tangent's constant mode
Definition: fbdata.h:280
FBTake::DuplicateSelectedLayers
void DuplicateSelectedLayers()
Duplicate the selected layers.
FBFCurve::KeySetRightTangentWeight
void KeySetRightTangentWeight(int pIndex, float pValue)
Set the key right tangent weight at the specified index.
FBCurveCustomKeyChangeEvent::Time
FBPropertyTime Time
Read Only Property: Time of the key.
Definition: fbdata.h:953
FBAnimationNode::SetCandidate
bool SetCandidate(double *Data, bool pCheckLocked=false)
Set the current candidate values for current time.
kFBPropertyStateEventTypeDestroyed
@ kFBPropertyStateEventTypeDestroyed
Property connector was destroyed (property animation was deleted)
Definition: fbdata.h:1307
FBAnimationNode::Label
FBPropertyString Label
Read Write Property: Label (UI Name).
Definition: fbdata.h:1194
FBTake::MoveCurrentLayerDown
bool MoveCurrentLayerDown()
Move the current layer down, similar to using the button to move the layer in the Animation Layer too...
FBFCurveKey::FBFCurveKey
FBFCurveKey(const FBFCurveKey &pFCurveKey)
Constructor.
kFBTangentModeTimeIndependent
@ kFBTangentModeTimeIndependent
Time independent, is calculated based upon the slope between the previous and next key values....
Definition: fbdata.h:148
FBTake::SetCurrentLayer
void SetCurrentLayer(int pLayerIndex)
Set the current layer for the take.
kFBPropertyStateEventTypeDetached
@ kFBPropertyStateEventTypeDetached
Property connector was detached (property animation was delete from the scene, but it still keep in c...
Definition: fbdata.h:1306
FBFCurveCustomTangent::FBDelete
virtual void FBDelete() override
Virtual FBDelete function.
FBFCurveKey::MarkedForManipulation
FBPropertyBool MarkedForManipulation
Read Write Property: Is the key marked for manipulation.
Definition: fbdata.h:286
FBTake::GetCurrentLayer
int GetCurrentLayer()
Get the current layer for the take.
FBCurveCustomKeyAddEvent::GetParentComponent
FBComponent * GetParentComponent()
Return the parent object holding the FBAnimationNode of the curve if possible.
kFBInterpolationCount
@ kFBInterpolationCount
Number of interpolation types.
Definition: fbdata.h:123
FBEventAnimationNode::Type
FBPropertyEventAnimationNodeType Type
Read Only Property: Type of selection event.
Definition: fbdata.h:855
kFBAnimLayerMerge_AllLayers_AllProperties
@ kFBAnimLayerMerge_AllLayers_AllProperties
Merge the animation of all properties of the selected models from all the layers to the BaseAnimation...
Definition: fbdata.h:1615
kFBLayerRotationModeEulerRotation
@ kFBLayerRotationModeEulerRotation
The rotation will be computed component by component.
Definition: fbdata.h:1490
FBFCurveKey::operator==
bool operator==(const FBFCurveKey &pValue) const
Overloaded == operator.
FBPropertyEventAnimationNodeKeyAdd
PropertyEvent: Event when a key that doesn't have a custom tangent is added.
Definition: fbdata.h:1000
FBPropertyListTake::Add
virtual int Add(FBComponent *pItem) override
Add a component to the list.
FBAnimationLayer::IsSelected
bool IsSelected()
Verify if the layer is selected.
kFBPropertyComponent1
@ kFBPropertyComponent1
Second component (e.g.: Y, Green, etc.).
Definition: fbdata.h:1638
kFBFCurveEventTypeKeyMassOperation
@ kFBFCurveEventTypeKeyMassOperation
An operation affecting multiple keys was made.
Definition: fbdata.h:1362
kFBTangentCustomIndex0
@ kFBTangentCustomIndex0
First custom tangent type registered in the system.
Definition: fbdata.h:199
kFBFCurveEventTypeKeyTensionChanged
@ kFBFCurveEventTypeKeyTensionChanged
A key tension was changed (only valid on TCB key)
Definition: fbdata.h:1357
FBFCurveKey::TangentClampMode
FBPropertyTangentClampMode TangentClampMode
Read Write Property: Tangent's clamp method.
Definition: fbdata.h:278
FBTimeWarpManager::GetTimeWarpNickNumberAtIndex
int GetTimeWarpNickNumberAtIndex(FBTake *pTake, kLong pIndex)
Get the Nick Number of one TimeWarp At specific index in a Take.
FBTake::GetTimeMarkColor
FBColor GetTimeMarkColor(int pIndex)
Returns the color associated with a time mark.
FBAnimationLayer::GetChildLayer
FBAnimationLayer * GetChildLayer(int pIndex)
Get the nth child layer of this layer.
FBFCurve::KeySetInterpolation
void KeySetInterpolation(int pIndex, FBInterpolation pValue)
Set the key interpolation type at the specified index.
FBAnimationStack::FBDelete
virtual void FBDelete() override
Virtual FBDelete function.
kFBAnimationNodeConnectorTypeNone
@ kFBAnimationNodeConnectorTypeNone
The animation node connector is not connected and doesn't have a constant value set to it.
Definition: fbdata.h:188
FBFCurveEventManager::TheOne
static FBFCurveEventManager & TheOne()
Get the global object for this class.
FBCurveCustomKeyChangeEvent
This class is used when changing the interpolation type/custom tangent index of a key with a custom t...
Definition: fbdata.h:932
FB_DEFINE_ENUM
#define FB_DEFINE_ENUM(DllTag, Type)
Define an enum and give it the ability to be a property.
Definition: fbproperties.h:150
kFBAnimationNodeConnectorTypeConnectedIn
@ kFBAnimationNodeConnectorTypeConnectedIn
The animation node input connector is connected to an animation node output connector (valid for inpu...
Definition: fbdata.h:189
FBFCurveEventManager
FCurve Event Manager Interface to the FBFCurveEventManager.
Definition: fbdata.h:1439
kFBPropertyComponentAll
@ kFBPropertyComponentAll
All components.
Definition: fbdata.h:1641
FBCurveEvaluationEvent::Curve
FBPropertyFCurve Curve
Read Only Property: Curve to evaluate.
Definition: fbdata.h:880
FBFCurveKey::TangentBreak
FBPropertyBool TangentBreak
Read Write Property: Tangent's break status
Definition: fbdata.h:279
FBFCurveCustomTangent::CustomTangentName
FBPropertyString CustomTangentName
Read Only Property: Name of custom tangent, will be displayed in the interface.
Definition: fbdata.h:751
kFBFCurveEventTypeKeyInterpolationChanged
@ kFBFCurveEventTypeKeyInterpolationChanged
A key interpolation mode was changed.
Definition: fbdata.h:1350
FBTake::SetTimeMarkName
bool SetTimeMarkName(int pIndex, const char *pName)
Sets a new name for an existing time mark.
FBFCurve::KeySetTangentConstantMode
void KeySetTangentConstantMode(int pIndex, FBTangentConstantMode pValue)
Set the key tangent's constant mode at the specified index.
FBAnimationNode::GetAnimationToRecord
FBAnimationNode * GetAnimationToRecord()
Get animation node to record to.
FBTangentClampMode
FBTangentClampMode
Different clamping modes for the tangents.
Definition: fbdata.h:156
FBFCurve::GetPostExtrapolationCount
int GetPostExtrapolationCount()
Get count for post extrapolation.
FBAnimationNode::UserName
FBPropertyString UserName
Read Only Property: Name of animation node.
Definition: fbdata.h:1195
kFBLayerModeAdditive
@ kFBLayerModeAdditive
Layer value will be added to the other layers to computed the final value.
Definition: fbdata.h:1479
kFBPropertyComponent2
@ kFBPropertyComponent2
Third component (e.g.: Z, Blue, etc.).
Definition: fbdata.h:1639
FBAnimationLayer::FBAnimationLayer
FBAnimationLayer(const char *pName, int pLayerID, HIObject pObject=NULL)
Constructor.
FBFCurveKey::LeftDerivative
FBPropertyFloat LeftDerivative
Read Write Property: Left derivative, in units/seconds.
Definition: fbdata.h:263
FBPropertykReference
class K_DLLIMPORT FBPropertyBase< kReference, kFBPT_kReference > FBPropertykReference
Property: kReference
Definition: fbproperties.h:1355
FBCurveCustomKeyAddEvent::GetParentAnimationNode
FBAnimationNode * GetParentAnimationNode()
Return the parent FBAnimationNode of the curve if possible.
FBAnimationNode::KeyRemoveAt
void KeyRemoveAt(FBTime pTime)
Remove key at the specified time.
FBAnimationNode
Definition: fbdata.h:1047
FBCurveCustomKeyAddEvent::Curve
FBPropertyFCurve Curve
Read Only Property: Curve that will receive the new key.
Definition: fbdata.h:913
FBPropertyInt
class K_DLLIMPORT FBPropertyBase< int, kFBPT_int > FBPropertyInt
Property: int
Definition: fbproperties.h:1331
FBFCurveEventManager::UnregisterProperty
bool UnregisterProperty(FBPropertyAnimatable *pProperty)
Unregister a property from the FCurve Event Manager.
FBFCurveKey::TangentWeightMode
FBPropertyTangentWeightMode TangentWeightMode
Read Write Property: Tangent's weight mode. Setting the value for LeftTangentWeight/RightTangentWeigh...
Definition: fbdata.h:281
FBTake::PlotTakeOnProperties
void PlotTakeOnProperties(FBTime pPlotPeriod, FBArrayTemplate< FBProperty * > *pPropertiesToPlot)
Plot the animation on given properties.
FBEventAnimationNode
The transform manipulator has begun doing modifications This event occurs every time a manipulator:
Definition: fbdata.h:848
FBPropertyEventAnimationNodeEvaluate
PropertyEvent: Event when a custom tangent that needs to be evaluated.
Definition: fbdata.h:985
FBFCurve::KeySetMarkedForManipulation
bool KeySetMarkedForManipulation(int pIndex, bool pValue)
Set the key manipulation state.
kFBTangentModeClampProgressive
@ kFBTangentModeClampProgressive
Time independent, will flatten the tangent handles when the key value goes over or under the previous...
Definition: fbdata.h:149
FBAnimationLayer::SetParentLayer
void SetParentLayer(FBAnimationLayer *pParentLayer)
Set the parent layer.
FBFCurve::SetPostExtrapolationCount
void SetPostExtrapolationCount(int pCount)
Set count for post extrapolation.
FBTake::OffsetAnimation
bool OffsetAnimation(FBTime &pOffsetTime, FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true, int pLayerID=-1, bool pOnLockedProperties=false)
Offset the animation (FCurve keys) of this take object within a time range by a given offset time.
kFBTimeMarkAction_None
@ kFBTimeMarkAction_None
No action. The mark is just visual hint.
Definition: fbdata.h:1630
FBTimeWarpManager::TimeWarpAddToTake
void TimeWarpAddToTake(FBTake *pTake, FBAnimationNode *pTimeWarp, int pNickNumber=0)
Add one TimeWarp to a Take.
FBTake::Comments
FBPropertyString Comments
Read Write Property: Take comments.
Definition: fbdata.h:1849
kFBLayerModeInvalidIndex
@ kFBLayerModeInvalidIndex
Invalid value.
Definition: fbdata.h:1478
FBPropertyListTake::operator[]
FBTake * operator[](int pIndex)
Get the take at pIndex.
FBPropertyStateEventType
FBPropertyStateEventType
This enum indicates what modification was made to the animation of a tracked property.
Definition: fbdata.h:1303
FBTake::PlotTakeOnSelectedProperties
void PlotTakeOnSelectedProperties(FBTime pPlotPeriod)
Plot the animation on selected properties.
FBFCurveKey::Continuity
FBPropertyFloat Continuity
Read Write Property: Continuity (TCB).
Definition: fbdata.h:272
FBFCurveCustomTangentManager::OnKeyAdd
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
FBCurveCustomKeyChangeEvent::GetParentAnimationNode
FBAnimationNode * GetParentAnimationNode()
Return the parent FBAnimationNode of the curve if possible.
kFBAnimationNodeConnectorTypeConstantIn
@ kFBAnimationNodeConnectorTypeConstantIn
The animation node input connector has a constant value set to it (valid for input connector only).
Definition: fbdata.h:191
FBBox
A box is a fundamental building block in the application architecture.
Definition: fbcore.h:218
kFBTangentClampModeClamped
@ kFBTangentClampModeClamped
The tangent will be flattened when the key is placed at the same value as an adjacent key.
Definition: fbdata.h:158
FBAnimationNodeConnectorType
FBAnimationNodeConnectorType
Different types for the animation node connectors.
Definition: fbdata.h:187
FBPropertyEventAnimationNodeCustomKeyAdd
PropertyEvent: Event when a key with a custom tangent that needs some of its parameters to be specifi...
Definition: fbdata.h:1015
FBTake::PlotTakeOnSelectedProperties
void PlotTakeOnSelectedProperties(FBPlotOptions *pPlotOptions)
Plot the animation on selected properties.
FBAnimationNode::DefaultInterpolation
FBPropertyInterpolation DefaultInterpolation
Read Write Property: Default type of interpolation.
Definition: fbdata.h:1202
FBInterpolatorCurveType
FBInterpolatorCurveType
Types of interpolator for an FCurve.
Definition: fbdata.h:128
kFBTangentModeUser
@ kFBTangentModeUser
Used to represent all splines with no lost data (HERMITE, BEZIER, CATMUL, etc.)
Definition: fbdata.h:146
FBFCurveKey::~FBFCurveKey
~FBFCurveKey()
Destructor.
FBFCurve::KeySetSelected
bool KeySetSelected(int pIndex, bool pValue)
Set the key selected state.
FBLayerRotationMode
FBLayerRotationMode
Rotation mode for layer.
Definition: fbdata.h:1488
FBPropertyListAnimationNode::Find
FBAnimationNode * Find(const char *pNodeName)
Find an animation node.
FBEventAnimationNodeType
FBEventAnimationNodeType
Event based on animation node.
Definition: fbdata.h:831
kFBTangentConstantModeNormal
@ kFBTangentConstantModeNormal
The tangent will contain the value of the current keyframe until the next keyframe.
Definition: fbdata.h:167
FBTake::GetNextTimeMarkIndex
int GetNextTimeMarkIndex()
Returns the next time mark index, based on the current local time.
FBAnimationLayer::Mute
FBPropertyBool Mute
Read Write Property: If true, the layer is muted. A muted layer is not included in the result animati...
Definition: fbdata.h:1523
kFBInterpolationCustom
@ kFBInterpolationCustom
Custom interpolation.
Definition: fbdata.h:122
kFBFCurveEventTypeKeyTangentBreakChanged
@ kFBFCurveEventTypeKeyTangentBreakChanged
A key break mode was changed.
Definition: fbdata.h:1352
FBFCurveCustomTangentManager::AddCustomTangentType
int AddCustomTangentType(const char *pTangentName, const char *pTangentFBXName)
Register a new custom tangent in the system.
FBFCurve::KeyGetRightDerivative
float KeyGetRightDerivative(int pIndex)
Get the key right derivative value at the specified index.
FBPropertyComponents
FBPropertyComponents
Property Components Bit Field (XYZ, RGB, RGBA, UV, XYZW, etc.).
Definition: fbdata.h:1636
FBPlotOptions
Option parameters for plotting.
Definition: fbapplication.h:186
FBTime::Infinity
static const FBTime Infinity
Time constant: Infinity, the largest time value.
Definition: fbtime.h:257
FBTimeWarpManager::TimeWarpRegisterChangeEvent
void TimeWarpRegisterChangeEvent(TimeWarpChangeCallback pCallback, void *pObject)
Register a callback Called when some changes related to TimeWarp happen.
FBFCurve::Keys
FBPropertyListFCurveKey Keys
List: Keys.
Definition: fbdata.h:485
FBFCurve::FBDelete
virtual void FBDelete() override
Virtual FBDelete function.
kFBPropertyStateEventTypeUnknownOperation
@ kFBPropertyStateEventTypeUnknownOperation
Invalid event.
Definition: fbdata.h:1304
FBTimeWarpManager
Time Warp Manager Interface to the Time Warp Manager.
Definition: fbdata.h:2118
FBPropertyListAnimationNode::Remove
virtual int Remove(FBAnimationNode *pItem)
Remove an animation node from the list.
FBAnimationNode::KeyRemove
void KeyRemove()
Remove key at current time.
kFBFCurveEventTypeKeyContinuityChanged
@ kFBFCurveEventTypeKeyContinuityChanged
A key continuity was changed (only valid on TCB key)
Definition: fbdata.h:1358
FBTimeWarpManager::FBTimeWarpManager
FBTimeWarpManager()
Constructor.
FBFCurveKey::RightTangentWeight
FBPropertyFloat RightTangentWeight
Read Write Property: Right tangent weight
Definition: fbdata.h:266
FBFCurve::KeyGetLeftTangentWeight
float KeyGetLeftTangentWeight(int pIndex)
Get the key left tangent weight at the specified index.
FBAnimationLayer::GetCompleteChildHierarchy
void GetCompleteChildHierarchy(FBArrayTemplate< FBAnimationLayer * > *pChildArray)
Get the all the children hierarchy of the layer, including children not directly connected to this la...
FBFCurveEvent::CurveName
FBPropertyString CurveName
Read Only Property: Name of curve.
Definition: fbdata.h:1396
kFBInterpolationCubic
@ kFBInterpolationCubic
Cubic interpolation.
Definition: fbdata.h:121
FBFCurveCustomTangentManager::OnEvaluate
FBPropertyEventAnimationNodeEvaluate OnEvaluate
Event: Called when evaluating the node, you must evaluate your curve and return the computed value.
Definition: fbdata.h:1283
FBAnimationLayer::Weight
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
FBExtrapolationMode
FBExtrapolationMode
Modes for pre / post extrapolation.
Definition: fbdata.h:175
FBPropertyListAnimationNode::RemoveAt
virtual void RemoveAt(int pIndex)
Remove an animation node from pIndex.
FBPropertyDouble
class K_DLLIMPORT FBPropertyBase< double, kFBPT_double > FBPropertyDouble
Property: double
Definition: fbproperties.h:1340
FBTake::PlotAllTakesOnProperties
void PlotAllTakesOnProperties(FBTime pPlotPeriod, FBArrayTemplate< FBProperty * > *pPropertiesToPlot)
Plot the animation on given properties for all takes.
kFBTangentWeightModeNextLeft
@ kFBTangentWeightModeNextLeft
Next key left tangent weight active.
Definition: fbdata.h:211
FBFCurve::KeyGetTangentCustomIndex
FBTangentCustomIndex KeyGetTangentCustomIndex(int pIndex)
Get the key tangent's custom index at the specified index.
FBPropertyListCustomTangent::FBPropertyListCustomTangent
FBPropertyListCustomTangent()
Constructor.
FBTake::DeleteAnimationOnObjects
bool DeleteAnimationOnObjects(FBArrayTemplate< FBBox * > *pObjects, FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true, int pLayerID=-1, bool pOnLockedProperties=false)
Delete animation (FCurve keys) of this take object on given objects within a time range.
FBCurveEvaluationEvent::FBCurveEvaluationEvent
FBCurveEvaluationEvent(HKEventBase pEvent)
Constructor.
FBInterpolation
FBInterpolation
Types of interpolation for an FCurve.
Definition: fbdata.h:117
FBFCurveEvent::EventType
FBPropertyFCurveEventType EventType
Read Only Property: Type of fcurve event.
Definition: fbdata.h:1392
kFBFCurveEventTypeUnknownOperation
@ kFBFCurveEventTypeUnknownOperation
Invalid event.
Definition: fbdata.h:1344
FBTimeWarpManager::TimeWarpRename
void TimeWarpRename(FBTake *pTake, FBAnimationNode *pTimeWarp, const char *pNewName)
FBAnimationNode::WriteData
bool WriteData(double *Data, FBEvaluateInfo *pEvaluateInfo)
Write data to animation node.
FBFCurveKey::Tension
FBPropertyFloat Tension
Read Write Property: Tension (TCB).
Definition: fbdata.h:271
FBTime
Time data structure.
Definition: fbtime.h:88
FBAnimationStack
Used to access animation stack.
Definition: fbdata.h:1223
FBCurveEvaluationEvent::Result
FBPropertyDouble Result
Read Write Property: Write the resulting value in that prorperty.
Definition: fbdata.h:881
FBFCurveCustomTangent::CustomTangentFBXName
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
kFBPropertyStateEventTypeMassOperation
@ kFBPropertyStateEventTypeMassOperation
Property was heavily modified (switching to story tool, story clip deleted...)
Definition: fbdata.h:1308
FBEventAnimationNode::FBEventAnimationNode
FBEventAnimationNode(HKEventBase pEvent)
Constructor.
FBTimeWarpManager::TheOne
static FBTimeWarpManager & TheOne()
Get the global object for this class.
FBFCurve::KeySetLeftBezierTangent
void KeySetLeftBezierTangent(int pIndex, float pValue)
Set the key left bezier tangent value at the specified index.
FBFCurveKey::LeftBezierTangent
FBPropertyFloat LeftBezierTangent
Read Write Property: Left bezier tangent
Definition: fbdata.h:267
FBPropertyStateEvent::GetParentComponent
FBComponent * GetParentComponent()
Return the parent object holding the property if possible.
FBTake::GetTimeMarkAction
FBTimeMarkAction GetTimeMarkAction(int pIndex)
Returns the action associated with a time mark.
FBCurveCustomKeyChangeEvent::ChangeType
FBPropertyCustomKeyChangeType ChangeType
Read Write Property: Indicate which setting of the key was/will be changed.
Definition: fbdata.h:950
FBAnimationNode::RecordMode
FBPropertyBool RecordMode
Read Write Property: Is the node in recording mode (device connectors)?
Definition: fbdata.h:1200
FBFCurveCustomTangent::CustomTangentIndex
FBPropertyInt CustomTangentIndex
Read Only Property: Index of the custom tangent in the system. When you will evaluate a key with your...
Definition: fbdata.h:753
FBPropertyStateEvent::EventType
FBPropertyPropertyStateEventType EventType
Read Only Property: Event type, please see the FBPropertyStateEventType for the possible types.
Definition: fbdata.h:1333
FBFCurve::KeyGetTCBContinuity
float KeyGetTCBContinuity(int pIndex)
Get the key continuity value at the specified index (TCB key).
FBTangentConstantMode
FBTangentConstantMode
Different constant modes for the tangents.
Definition: fbdata.h:166
FBTimeWarpManager::GetTimeWarpNickNumber
int GetTimeWarpNickNumber(FBTake *pTake, FBAnimationNode *pTimeWarp)
Get the Nick Number of one TimeWarp in a Take.
kFBTangentClampModeNone
@ kFBTangentClampModeNone
The tangent will act normally.
Definition: fbdata.h:157
FBFCurve::KeySetTCBTension
void KeySetTCBTension(int pIndex, float pValue)
Set the key tension value at the specified index (TCB key).
FBTake::GetLayerCount
int GetLayerCount()
Get the layer count.
FBCurveCustomKeyAddEvent::FBCurveCustomKeyAddEvent
FBCurveCustomKeyAddEvent(HKEventBase pEvent)
Constructor.
FBAnimationNode::ReadData
bool ReadData(double *Data, FBTime pTime, bool pConvertGlobalToLocal=false)
Read data from animation node.
FBCurveEvaluationEvent
This class is used when an evaluation must be done on your custom tangents. It contains the necessary...
Definition: fbdata.h:865
FBFCurve::GetPreExtrapolationCount
int GetPreExtrapolationCount()
Get count for pre extrapolation.
kFBPropertyStateEventTypeAttached
@ kFBPropertyStateEventTypeAttached
Property connector was added (can happen when undoing a delete operation, which set back the property...
Definition: fbdata.h:1305
kFBPropertyComponent0
@ kFBPropertyComponent0
First component (e.g.: X, Red, etc.).
Definition: fbdata.h:1637
FBTake::LocalTimeSpan
FBPropertyTimeSpan LocalTimeSpan
Read Write Property: Local time span.
Definition: fbdata.h:1848
FBCurveEvaluationEvent::KeyIndex
FBPropertyDouble KeyIndex
Read Only Property: Index of the key to evaluate, a decimal value indicates an evaluation between two...
Definition: fbdata.h:878
FBAnimationNode::ConvertNodeToGlobalTime
FBTime ConvertNodeToGlobalTime(FBTime &pKeyTime)
Convert node time to global time.
FBFCurveKey::FBFCurveKey
FBFCurveKey(::KFCurve *pFCurve=NULL, int pKeyIndex=1)
Constructor.
FBTake::SetTimeMarkColor
bool SetTimeMarkColor(int pIndex, FBColor pColor)
Sets a new color for an existing time mark.
FBFCurve::KeyGetSelected
bool KeyGetSelected(int pIndex)
Get the key selected state.
FBPropertyChanged
PropertyEvent: Event when a property is modified, to be used with the FBFCurveEventManager.
Definition: fbdata.h:1405
FBAnimationNode::IsKey
bool IsKey()
Verifies if there is a key at the current.
FBXtoFBProperty
K_DLLIMPORT 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...
FBFCurveCustomTangentManager::GetCustomTangentTypeName
const char * GetCustomTangentTypeName(int pIndex)
Return the UI name of the custom tangent at the specified index.
FBAnimationNode::IsEvaluationRecursive
bool IsEvaluationRecursive(FBEvaluateInfo *pEvaluateInfo)
Return true if the animation node had valid data for pEvaluateInfo and read from this connector cause...
FBFCurve::KeySetTangentWeightMode
void KeySetTangentWeightMode(int pIndex, FBTangentWeightMode pValue)
Change the tangent weight for a key.
FBPropertyEventAnimationNode::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
FBPropertyEventAnimationNodeEvaluate::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
kFBInterpolationChange
@ kFBInterpolationChange
The interpolation of the key was/will be modified (FBInterpolation).
Definition: fbdata.h:925
FBTake::GetLayer
FBAnimationLayer * GetLayer(int pLayerIndex)
Get the layer object that have the specified ID.
FBTake
A take is a container for animation in a scene.
Definition: fbdata.h:1692
FBFCurve::KeyAdd
int KeyAdd(FBTime &pTime, double pValue, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto)
Add a key at the specified time.
FBTake::PlotTakeOnSelected
void PlotTakeOnSelected(FBTime pPlotPeriod)
Plot the animation on selected models.
FBTimeWarpManager::TimeWarpUnregisterChangeEvent
void TimeWarpUnregisterChangeEvent(TimeWarpChangeCallback pCallback, void *pObject)
Unregister a call registered.
FBPropertyChanged::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
FBFCurveCustomTangentManager
Custom Tangent Manager Interface to the Custom Tangent Manager.
Definition: fbdata.h:1249
FBFCurve::KeyRemove
bool KeyRemove(int pIndex)
Remove key at index.
kFBTangentModeAuto
@ kFBTangentModeAuto
This is the equivalent to a cardinal spline with no parametrization. In the UI, it is identified as S...
Definition: fbdata.h:144
FBCurveCustomKeyChangeEvent::IsPreCall
FBPropertyBool IsPreCall
Read Only Property: True before the value is actually changed (allowing you to cache the current stat...
Definition: fbdata.h:949
FBTangentCustomIndex
FBTangentCustomIndex
Custom tangent index for the tangents.
Definition: fbdata.h:198
FBFCurveKey::LeftTangentWeight
FBPropertyFloat LeftTangentWeight
Read Write Property: Left tangent weight
Definition: fbdata.h:265
FBFCurveCustomTangentManager::RemoveCustomTangentType
bool RemoveCustomTangentType(const char *pTangentName)
Remove a custom tangent from the system.
FBFCurve::KeyDelete
bool KeyDelete(FBTime pStart=FBTime::MinusInfinity, FBTime pStop=FBTime::Infinity, bool pInclusive=false)
Delete keys within a time range.
FBTimeWarpManager::GetTimeWarpFromNickNumber
FBAnimationNode * GetTimeWarpFromNickNumber(FBTake *pTake, int pNumber)
Get the timeWarp of specific Nick Number in a Take.
FBFCurve::KeyReplaceBy
void KeyReplaceBy(FBFCurve &pSource, FBTime pStart=FBTime::MinusInfinity, FBTime pStop=FBTime::Infinity, bool pUseExactGivenSpan=false, bool pKeyStartEndOnNoKey=true)
Replace keys within a range in current function curve with keys found in a source function curve.
FBTake::DeleteAllTimeMarks
void DeleteAllTimeMarks()
Delete all time marks from the take.
FBFCurveKey::RightDerivative
FBPropertyFloat RightDerivative
Read Write Property: Right derivative, in units/seconds.
Definition: fbdata.h:264
FBCurveCustomKeyAddEvent
This class is used when adding a key with a custom tangent to a curve. It contains the necessary info...
Definition: fbdata.h:894
FBFCurveCustomTangentManager::OnCustomKeyAdd
FBPropertyEventAnimationNodeCustomKeyAdd OnCustomKeyAdd
Event: Called when adding a key with a custom tangent, you must specify some of its parameters.
Definition: fbdata.h:1286
FBFCurve::KeyGetTCBBias
float KeyGetTCBBias(int pIndex)
Get the key bias value at the specified index (TCB key).
FBAnimationNode::OnChange
FBPropertyEventAnimationNode OnChange
Event: Called when the value of this property is modified
Definition: fbdata.h:1207
FBPropertyAnimatable
Animatable property base class.
Definition: fbproperties.h:1482
FBAnimationLayer::GetParentLayer
FBAnimationLayer * GetParentLayer()
Get the parent layer.
FBFCurve::KeyGetTCBTension
float KeyGetTCBTension(int pIndex)
Get the key tension value at the specified index (TCB key).
FBFCurveEvent::GetParentProperty
FBProperty * GetParentProperty()
Return the parent FBProperty of the curve if possible.
kFBFCurveEventTypeKeyVelocityChanged
@ kFBFCurveEventTypeKeyVelocityChanged
A key velocity was changed.
Definition: fbdata.h:1355
FBAnimationLayer::GetChildCount
int GetChildCount()
Get the child layer count of this layer.
FBTimeWarpManager::TimeWarpClearTake
void TimeWarpClearTake(FBTake *pTake)
Clear all TimeWarp in a Take, and removed from the DataSet.
FBTake::SetTimeMarkTime
int SetTimeMarkTime(int pIndex, FBTime pTime)
Sets a new time for an existing time mark.
FBPropertyTime
class K_DLLIMPORT FBPropertyBase< FBTime, kFBPT_Time > FBPropertyTime
Property: FBTime
Definition: fbproperties.h:1346
FBCurveEvaluationEvent::GetFBXCurve
FBXSDK_NAMESPACE::FbxAnimCurve * GetFBXCurve()
Get the FbxAnimCurve to evaluate, used in story tool for read-only clip.
FBFCurve::KeyGetRightBezierTangent
float KeyGetRightBezierTangent(int pIndex)
Get the key right bezier tangent value at the specified index.
FBFCurve::GetPostExtrapolationMode
FBExtrapolationMode GetPostExtrapolationMode()
Get modes for post extrapolation.
FBFCurve::CreateInterpolatorCurve
static FBFCurve * CreateInterpolatorCurve(FBInterpolatorCurveType pCurveType)
Create and interpolator curve.
FBAnimationLayer::LayerRotationMode
FBPropertyLayerRotationMode LayerRotationMode
Read Only Property: Layer rotation mode. Cannot be applied to the BaseAnimation Layer.
Definition: fbdata.h:1527
kFBTimeMarkAction_Loop
@ kFBTimeMarkAction_Loop
When reaching the mark, the playback loops to previous global mark (or start frame if any).
Definition: fbdata.h:1632
FBTake::GetTimeMarkTime
FBTime GetTimeMarkTime(int pIndex)
Returns the time associated with a time mark.
__FBClassDeclare
#define __FBClassDeclare(Name, Parent)
For internal use only.
Definition: fbcomponent.h:131
FBPropertyAnimatableDouble
class K_DLLIMPORT FBPropertyBaseAnimatable< double, kFBPT_double > FBPropertyAnimatableDouble
FBPropertyBaseAnimatableDouble type definition.
Definition: fbproperties.h:1752
FBTake::SetTimeMarkAction
bool SetTimeMarkAction(int pIndex, FBTimeMarkAction pAction)
Sets a new action for an existing time mark.
FBTime::MinusInfinity
static const FBTime MinusInfinity
Time constant: Minus Infinity, the lowest negative time value.
Definition: fbtime.h:260
FBCurveCustomKeyAddEvent::Time
FBPropertyTime Time
Read Only Property: Time where the key will be added.
Definition: fbdata.h:912
FBTake::DeleteAnimationOnProperties
bool DeleteAnimationOnProperties(FBArrayTemplate< FBProperty * > *pProperties, FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true, int pLayerID=-1, bool pOnLockedProperties=false, FBPropertyComponents pPropertyComponents=kFBPropertyComponentAll)
Delete animation (FCurve keys) of this take object on given properties within a time range.
kFBAnimLayerMerge_AllLayers_SelectedProperties
@ kFBAnimLayerMerge_AllLayers_SelectedProperties
Merge the animation of the selected properties of the selected models from all the layers to the Base...
Definition: fbdata.h:1613
FBPropertyStateEvent::GetProperty
FBProperty * GetProperty()
Return the FBProperty related to the event.
FBPropertyStateEvent
This class is used when the state of a property tracked by the FBFCurveEventManager is changed.
Definition: fbdata.h:1316
kFBTangentCustomIndex1
@ kFBTangentCustomIndex1
Second custom tangent type registered in the system.
Definition: fbdata.h:200
FBTimeWarpManager::TimeWarpMergeCurveNode
void TimeWarpMergeCurveNode(FBTake *pTake, FBProperty *pEvalProp, FBAnimationNode *pNode, FBAnimationNode *pTimeWarpNode)
FBProperty
Property: Base property class.
Definition: fbproperties.h:195
FBTake::CreateNewLayer
void CreateNewLayer()
Create a new layer.
__FB_FORWARD
#define __FB_FORWARD(ClassName)
Forwarding of class and typedef declaration.
Definition: fbtypes.h:68
FBTake::OffsetAnimationOnObjects
bool OffsetAnimationOnObjects(FBArrayTemplate< FBBox * > *pObjects, FBTime &pOffsetTime, FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true, int pLayerID=-1, bool pOnLockedProperties=false)
Offset the animation (FCurve keys) of this take object on given objects within a time range by a give...
kFBFCurveEventTypeKeyTangentChanged
@ kFBFCurveEventTypeKeyTangentChanged
A key tangent was changed.
Definition: fbdata.h:1351
FBCurveEvaluationEvent::RightCustomTangentTypeIndex
FBPropertyInt RightCustomTangentTypeIndex
Read Only Property: FbxAnimCurveOnly - Type of the right key custom tangent type, -1 if not a custom ...
Definition: fbdata.h:884
FBFCurveKey::Bias
FBPropertyFloat Bias
Read Write Property: Bias (TCB).
Definition: fbdata.h:273
FBTimeMarkAction
FBTimeMarkAction
Time (Global & Take) Mark assigned action.
Definition: fbdata.h:1629
FBPropertyBaseList
Definition: fbproperties.h:893
FBPropertyEventAnimationNodeCustomKeyChange::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
FBEvent
Base Event class.
Definition: fbcomponent.h:940
FBFCurve::KeySetTCBBias
void KeySetTCBBias(int pIndex, float pValue)
Set the key bias value at the specified index (TCB key).
FBTake::PlotAllTakesOnObjects
void PlotAllTakesOnObjects(FBTime pPlotPeriod, FBArrayTemplate< FBBox * > *pObjectsToPlot)
Plot the animation on given objects for all takes.
FBAnimationLayer::GetLayerIndex
int GetLayerIndex()
Get the layer index.
FBTimeWarpManager::TimeWarpInitTake
void TimeWarpInitTake(FBTake *pTake)
Allocate container for the TimeWarp in one Take.
FBCustomKeyChangeType
FBCustomKeyChangeType
Indicate if the interpolation or the custom index of the key will be/was modified.
Definition: fbdata.h:923
FBFCurve::KeyGetLeftBezierTangent
float KeyGetLeftBezierTangent(int pIndex)
Get the key left bezier tangent value at the specified index.
FBFCurveChanged
PropertyEvent: Event when a fcurve is changed.
Definition: fbdata.h:1420
FBTimeWarpManager::RemoveTimeWarpFromScene
void RemoveTimeWarpFromScene(FBAnimationNode *pTimeWarp)
Remove a TimeWarp from Scene.
kFBFCurveEventTypeKeyTimeChanged
@ kFBFCurveEventTypeKeyTimeChanged
A key time was changed.
Definition: fbdata.h:1347
kFBAnimLayerMerge_AllLayers_CompleteScene
@ kFBAnimLayerMerge_AllLayers_CompleteScene
Merge the animation of all properties from all the layers to the BaseAnimation layer.
Definition: fbdata.h:1617
FBLayerMode
FBLayerMode
Layer mode.
Definition: fbdata.h:1477
FBTake::GetPreviousTimeMarkIndex
int GetPreviousTimeMarkIndex()
Returns the previous time mark index, based on the current local time.
FBAnimationLayer::AddChildLayer
void AddChildLayer(FBAnimationLayer *pAnimationLayer)
Add a child to the layer.
FBTimeWarpManager::GetTimeWarpAtIndex
FBAnimationNode * GetTimeWarpAtIndex(FBTake *pTake, kLong pIndex)
Get the TimeWarp in a Take At specific Index.
kFBFCurveEventTypeKeyAdded
@ kFBFCurveEventTypeKeyAdded
A new key was added.
Definition: fbdata.h:1345
FBTake::GetTimeMarkName
const char * GetTimeMarkName(int pIndex)
Returns the name associated with a time mark.
kFBAnimLayerMerge_SelectedLayers_CompleteScene
@ kFBAnimLayerMerge_SelectedLayers_CompleteScene
Merge the animation of all properties from the selected layers to the selected layer with the lowest ...
Definition: fbdata.h:1616
FBPropertyEventAnimationNodeCustomKeyChange
PropertyEvent: Event when a key tangent is changed to a custom tangent/changed to another type from a...
Definition: fbdata.h:1030
FBFCurve
FCurve class.
Definition: fbdata.h:340
FBPropertyListAnimationNode
List of animation nodes.
Definition: fbdata.h:782
FBAnimationNode::ConvertGlobalToNodeTime
FBTime ConvertGlobalToNodeTime(FBTime &pKeyTime)
Convert global time to node time.
FBPropertyListCustomTangent::operator[]
FBFCurveCustomTangent * operator[](int pIndex)
Get the custom tangent at pIndex.
FBTangentMode
FBTangentMode
Methods of tangent calculation.
Definition: fbdata.h:143
FBTake::DeleteAnimation
bool DeleteAnimation(FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true, int pLayerID=-1, bool pOnLockedProperties=false)
Delete animation (FCurve keys) of this take object within a time range.
FBFCurveEvent::KeyIndexStart
FBPropertyInt KeyIndexStart
Read Only Property: Index of the first key which is involved in the event.
Definition: fbdata.h:1393
FBFCurve::KeyGetTangentWeightMode
FBTangentWeightMode KeyGetTangentWeightMode(int pIndex)
Get the tangent weight mode for a key.
FBFCurve::SetPreExtrapolationCount
void SetPreExtrapolationCount(int pCount)
Set count for pre extrapolation.
FBTake::ClearAllPropertiesOnCurrentLayer
void ClearAllPropertiesOnCurrentLayer()
Clear all the animation on the current layer.
FBAnimationLayer::Solo
FBPropertyBool Solo
Read Write Property: If true, the layer is soloed. When you solo a layer, you mute other layers that ...
Definition: fbdata.h:1522
FBAnimationNode::ConnectorType
FBPropertyAnimationNodeConnectorType ConnectorType
Read Only Property: Animation node connector type.
Definition: fbdata.h:1203
kFBTangentModeBreak
@ kFBTangentModeBreak
Like USER but left slope may differ from right.
Definition: fbdata.h:147
FBAnimationNode::Evaluate
bool Evaluate(double *Data, FBTime pTime, bool pEvaluateCandidate=true)
Evaluate the animation node data for a given time.
FBFCurveEventManager::OnPropertyEvent
FBPropertyChanged OnPropertyEvent
Event: Called when a registered property state is modified (detached, destroyed......
Definition: fbdata.h:1462
kFBFCurveEventTypeKeyPreExtrapolationChanged
@ kFBFCurveEventTypeKeyPreExtrapolationChanged
A curve pre-extrapolation value was changed.
Definition: fbdata.h:1360
kFBFCurveEventTypeKeyBiasChanged
@ kFBFCurveEventTypeKeyBiasChanged
A key bias was changed (only valid on TCB key)
Definition: fbdata.h:1359
kFBTangentWeightModeBoth
@ kFBTangentWeightModeBoth
Right tangent and next key left tangent weight are active.
Definition: fbdata.h:212
FBFCurve::KeyGetTangentBreak
bool KeyGetTangentBreak(int pIndex)
Get the key tangent's break status at the specified index.
kFBFCurveEventTypeKeyValueChanged
@ kFBFCurveEventTypeKeyValueChanged
A key value was changed.
Definition: fbdata.h:1348
FBFCurveEvent::KeyIndexStop
FBPropertyInt KeyIndexStop
Read Only Property: Index of the last key which is involved in the event.
Definition: fbdata.h:1394
FBFCurveEvent::CurveIndex
FBPropertyInt CurveIndex
Read Only Property: Index of curve.
Definition: fbdata.h:1397
FBFCurveKey::Selected
FBPropertyBool Selected
Read Write Property: Is the key selected.
Definition: fbdata.h:285
FBFCurveCustomTangentManager::GetCustomTangentTypeCount
int GetCustomTangentTypeCount()
Return the number of tangent currently registered in the system.
FBAnimationNode::Nodes
FBPropertyListAnimationNode Nodes
List: List of animation nodes.
Definition: fbdata.h:1205
FBFCurveKey
KeyFrame for an FCurve.
Definition: fbdata.h:225
FBTake::ClearAllProperties
void ClearAllProperties(bool pOnSelectedObjectsOnly, bool pOnLockedProperties=false)
Clear the animation on all the properties.
kFBLayerRotationModeInvalidIndex
@ kFBLayerRotationModeInvalidIndex
Invalid value.
Definition: fbdata.h:1489
FBFCurve::KeySetLeftDerivative
void KeySetLeftDerivative(int pIndex, float pValue)
Set the key left derivative value at the specified index.
FBFCurveChanged::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
FBAnimationLayer::SelectLayer
void SelectLayer(bool pValue, bool pExclusiveSelect)
Select the layer.
FBFCurve::KeyGetInterpolation
FBInterpolation KeyGetInterpolation(int pIndex)
Get the key interpolation type at the specified index.
FBPropertyStateEvent::FBPropertyStateEvent
FBPropertyStateEvent(HKEventBase pEvent)
Constructor.
FBFCurve::KeySetLeftTangentWeight
void KeySetLeftTangentWeight(int pIndex, float pValue)
Set the key left tangent weight at the specified index.
kFBAnimLayerMerge_SelectedLayers_AllProperties
@ kFBAnimLayerMerge_SelectedLayers_AllProperties
Merge the animation of all properties of the selected models from the selected layers to the selected...
Definition: fbdata.h:1614
FBFCurve::KeyGetTangentMode
FBTangentMode KeyGetTangentMode(int pIndex)
Get the key tangent mode at the specified index.
FBTake::PlotTakeOnObjects
void PlotTakeOnObjects(FBTime pPlotPeriod, FBArrayTemplate< FBBox * > *pObjectsToPlot)
Plot the animation on given objects.
FBAnimationLayer::LayerMode
FBPropertyLayerMode LayerMode
Read Write Property: Layer mode. By default, the layer is in kFBLayerModeAdditive mode....
Definition: fbdata.h:1526
FBFCurve::KeySetTangentBreak
void KeySetTangentBreak(int pIndex, bool pValue)
Set the key tangent's break status at the specified index.
FBTake::GetTimeMarkCount
int GetTimeMarkCount()
Returns the number of time marks on the take.
FBTake::OffsetAnimationOnProperties
bool OffsetAnimationOnProperties(FBArrayTemplate< FBProperty * > *pProperties, FBTime &pOffsetTime, FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true, int pLayerID=-1, bool pOnLockedProperties=false, FBPropertyComponents pPropertyComponents=kFBPropertyComponentAll)
Offset the animation (FCurve keys) of this take object on given properties within a time range by a g...
FBPropertyEventAnimationNodeKeyAdd::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
FBFCurve::KeySetTangentCustomIndex
void KeySetTangentCustomIndex(int pIndex, FBTangentCustomIndex pValue)
Set the key tangent's custom index at the specified index.
FBPropertyEvent
PropertyEvent: Base event class.
Definition: fbproperties.h:515
FBAnimationNode::ReadData
bool ReadData(double *Data, FBEvaluateInfo *pEvaluateInfo, bool pConvertGlobalToLocal=false)
Read data from animation node.
FBFCurve::KeyGetTime
FBTime KeyGetTime(int pIndex)
Get the key time value at the specified index.
FBPropertyFloat
class K_DLLIMPORT FBPropertyBase< float, kFBPT_float > FBPropertyFloat
Property: float
Definition: fbproperties.h:1343
FBTake::GetLayerRealSelection
bool GetLayerRealSelection()
Real selection for layer.
FBFCurveCustomTangent
This class represents a custom tangents object in the system.
Definition: fbdata.h:739
FBAnimationNode::Parent
FBPropertyAnimationNode Parent
Read Only Property: Parent animation node.
Definition: fbdata.h:1201
FBFCurveKey::Interpolation
FBPropertyInterpolation Interpolation
Read Write Property: Type of interpolation.
Definition: fbdata.h:276
kFBLayerRotationModeQuaternionRotation
@ kFBLayerRotationModeQuaternionRotation
The rotation will be computed using quaternion.
Definition: fbdata.h:1491
FBTake::MoveCurrentLayerUp
bool MoveCurrentLayerUp()
Move the current layer up, similar to using the button to move the layer in the Animation Layer tool.
FBCurveCustomKeyChangeEvent::GetParentComponent
FBComponent * GetParentComponent()
Return the parent object holding the FBAnimationNode of the curve if possible.
FBFCurveEvent::GetParentAnimationNode
FBAnimationNode * GetParentAnimationNode()
Return the parent FBAnimationNode of the curve if possible.
FBFCurve::KeySetTangentMode
void KeySetTangentMode(int pIndex, FBTangentMode pValue)
Set the key tangent mode at the specified index.
FBAnimationNode::DisableIfNotWritten
void DisableIfNotWritten(FBEvaluateInfo *pEvaluateInfo)
AnimationNodeNotify is called on FBBox for every animation node that data was pulled by system.
FBFCurve::GetPreExtrapolationMode
FBExtrapolationMode GetPreExtrapolationMode()
Get modes for pre extrapolation.
FBPropertyBool
class K_DLLIMPORT FBPropertyBase< bool, kFBPT_bool > FBPropertyBool
Property: bool
Definition: fbproperties.h:1308
FBAnimationLayer::Lock
FBPropertyBool Lock
Read Write Property: If true, the layer is locked. You cannot modify keyframes on a locked layer.
Definition: fbdata.h:1524
FBTimeWarpManager::GetTimeWarpCount
kLong GetTimeWarpCount(FBTake *pTake)
Get the count of TimeWarp in a Take.
FBTake::FBDelete
virtual void FBDelete() override
Deletion method.
FBTimeWarpManager::TimeWarpCopyTake
void TimeWarpCopyTake(FBTake *pDstTake, FBTake *pSrcTake)
Copy all the TimeWarp in one Take, add to another Take.
kFBPropertyComponent3
@ kFBPropertyComponent3
Fourth component (e.g.: W, Alpha, etc.).
Definition: fbdata.h:1640
kFBFCurveEventTypeKeyWeightChanged
@ kFBFCurveEventTypeKeyWeightChanged
A key left/right weight was changed, please note that this event can affect the key specified in the ...
Definition: fbdata.h:1356
fbcomponent.h
Basic class definitions.
kFBCustomTangentChange
@ kFBCustomTangentChange
The custom tangent value was/will be modified (FBTangentCustomIndex).
Definition: fbdata.h:926
FBPropertyListAnimationNode::Find
FBAnimationNode * Find(FBBox *pOriginalOwner, const char *pDataType)
Find an animation node.
FBPropertyListAnimationNode::FindByLabel
FBAnimationNode * FindByLabel(const char *pNodeLabel)
Find an animation node by label name.
FBTake::ReferenceTimeSpan
FBPropertyTimeSpan ReferenceTimeSpan
Read Write Property: Reference time span.
Definition: fbdata.h:1847
FBFCurve::SetPreExtrapolationMode
void SetPreExtrapolationMode(FBExtrapolationMode pExtrapolationMode)
Set modes for pre extrapolation.
FBFCurveEventManager::RegisterProperty
bool RegisterProperty(FBPropertyAnimatable *pProperty)
Register a property to the FCurve Event Manager.
FBPropertyEventAnimationNodeCustomKeyAdd::Add
virtual void Add(HICallback pOwner, kICallbackHandler pHandler)
Add/Remove a callback.
kFBFCurveEventTypeKeyRemoved
@ kFBFCurveEventTypeKeyRemoved
A key was removed.
Definition: fbdata.h:1346
FBAnimationNode::Reference
FBPropertykReference Reference
Read Write Property: User-defined reference.
Definition: fbdata.h:1196
FBTake::PlotAllTakesOnSelectedProperties
void PlotAllTakesOnSelectedProperties(FBTime pPlotPeriod)
Plot the animation on selected properties for all takes.
FBFCurveEvent::Curve
FBPropertyFCurve Curve
Read Only Property: Curve that will receive the new key.
Definition: fbdata.h:1395
FBFCurveEvent::FBFCurveEvent
FBFCurveEvent(HKEventBase pEvent)
Constructor.
FB_DEFINE_LIST
#define FB_DEFINE_LIST(DllTag, Type)
Define a component list.
Definition: fbproperties.h:163
FBTake::PlotTakeOnSelected
void PlotTakeOnSelected(FBPlotOptions *pPlotOptions)
Plot the animation on selected models.
FBFCurve::EditBegin
void EditBegin(int pKeyCount=-1)
Setup function to begin adding keys.
kFBAnimationNodeConnectorTypeConnectedOut
@ kFBAnimationNodeConnectorTypeConnectedOut
The animation node output connector is connected to at least one animation node input connector (vali...
Definition: fbdata.h:190
FBFCurveKey::Time
FBPropertyTime Time
Read Write Property: Time of key.
Definition: fbdata.h:275
FBAnimationNode::ReadData
bool ReadData(double *Data)
Read the last data evaluated for this animation node ...
kFBMergeLayerModeOverride
@ kFBMergeLayerModeOverride
The resulting layer will be in override mode, if possible.
Definition: fbdata.h:1624
kFBTangentWeightModeNone
@ kFBTangentWeightModeNone
Tangent weight disabled.
Definition: fbdata.h:209
FBFCurve::Evaluate
float Evaluate(FBTime &pTime)
Evaluate FCurve at pTime.
FBFCurve::KeySetRightDerivative
void KeySetRightDerivative(int pIndex, float pValue)
Set the key right derivative value at the specified index.
FBAnimationNode::GetDataDoubleArrayCount
int GetDataDoubleArrayCount()
If the DataPtr is of numeric value type ...
kFBTimeMarkAction_Stop
@ kFBTimeMarkAction_Stop
When reaching the mark, the playback stops.
Definition: fbdata.h:1631
FBPropertyListTake
List: Take
Definition: fbdata.h:1589
FBFCurveKey::RightBezierTangent
FBPropertyFloat RightBezierTangent
Read Write Property: Right bezier tangent
Definition: fbdata.h:268
FBAnimationNode::SetBufferType
void SetBufferType(bool pGlobal)
Set buffer type for ANIMATIONNODE_TYPE_LOCAL_TRANSLATION, ANIMATIONNODE_TYPE_LOCAL_ROTATION and ANIMA...
FBPropertyListComponent
PropertyList: Concrete class for PropertyList of component
Definition: fbcomponent.h:536
FBTake::PlotAllTakesOnSelected
void PlotAllTakesOnSelected(FBTime pPlotPeriod)
Plot the animation on selected models for all takes.
FBAnimationNode::KeyCandidate
void KeyCandidate(FBTime pTime=FBTime::Infinity)
Keys the current candidate values if no time is specified, at current time.
kFBAnimLayerMerge_SelectedLayers_SelectedProperties
@ kFBAnimLayerMerge_SelectedLayers_SelectedProperties
Merge the animation of the selected properties of the selected models from the selected layers to the...
Definition: fbdata.h:1612
kFBDataHandler
bool(* kFBDataHandler)(void *pBuffer, FBEvaluateInfo *pEvaluateInfo, FBAnimationNode *pAnimationNode, void *p1, void *p2)
kFBDataHandler
Definition: fbdata.h:978
FBTake::RemoveLayer
void RemoveLayer(int pLayerIndex)
Remove a layer.
FBTake::MergeLayers
void MergeLayers(FBAnimationLayerMergeOptions pMergeOptions, bool pDeleteMergedLayers, FBMergeLayerMode pMergeMode, bool pMergeLockedProperties=false)
Merge the selected layers.
FBMergeLayerMode
FBMergeLayerMode
Merge layer mode for animation layers. This will specify the mode of the resulting merged layer,...
Definition: fbdata.h:1621
kFBFCurveEventTypeKeyTangentClampModeChanged
@ kFBFCurveEventTypeKeyTangentClampModeChanged
A key clamping mode was changed.
Definition: fbdata.h:1353
FBArrayTemplate
Template class to contain an array of items.
Definition: fbarray.h:78
FBCurveEvaluationEvent::LeftCustomTangentTypeIndex
FBPropertyInt LeftCustomTangentTypeIndex
Read Only Property: FbxAnimCurveOnly - Type of the left key custom tangent type, -1 if not a custom t...
Definition: fbdata.h:883
FBPropertyListFCurveKey
List of FCurveKey.
Definition: fbdata.h:299
FBFCurve::KeyGetRightTangentWeight
float KeyGetRightTangentWeight(int pIndex)
Get the key right tangent weight at the specified index.
FBPropertyListAnimationNode::GetCount
virtual int GetCount()
Get a count of the number of animation nodes in list.
FBFCurve::KeySetTime
void KeySetTime(int pIndex, FBTime pValue)
Set the key time value at the specified index.
FBTake::DeleteTimeMark
bool DeleteTimeMark(int pIndex)
Delete a time mark from the take.
FBAnimationStack::FBAnimationStack
FBAnimationStack(const char *pName, HIObject pObject=NULL)
Constructor.
FBFCurve::KeySetRightBezierTangent
void KeySetRightBezierTangent(int pIndex, float pValue)
Set the key right bezier tangent value at the specified index.
FB_FORWARD
#define FB_FORWARD(ClassName)
Forwarding of class and typedef declaration.
Definition: fbtypes.h:62
FBPropertyListCustomTangent
List: Custom Tangent
Definition: fbdata.h:761
FBColor
Color vector.
Definition: fbtypes.h:448
FBAnimationLayerMergeOptions
FBAnimationLayerMergeOptions
Merge option for animation layers.
Definition: fbdata.h:1611
FBAnimationNode::FBAnimationNode
FBAnimationNode(const char *pName=NULL, HIObject pObject=NULL)
Constructor.
FBCurveEvaluationEvent::Time
FBPropertyTime Time
Read Only Property: Time to evaluate.
Definition: fbdata.h:879
FBTimeWarpManager::SetTimeWarpNickNumber
bool SetTimeWarpNickNumber(FBTake *pTake, FBAnimationNode *pTimeWarp, int pNumber)
Set the Nick Number of one TimeWarp in a Take.
FBFCurveEvent::GetParentComponent
FBComponent * GetParentComponent()
Return the parent object holding the FBAnimationNode of the curve if possible.
FBtoFBXProperty
K_DLLIMPORT 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.
FBFCurveEvent
This class is used when a modification is made on a FCurve. It contains the necessary information to ...
Definition: fbdata.h:1370
FBPropertyListFCurveKey::GetCount
virtual int GetCount()
Get a count of the number of keys in list.
FBFCurve::SetPostExtrapolationMode
void SetPostExtrapolationMode(FBExtrapolationMode pExtrapolationMode)
Set modes for post extrapolation.
FBFCurve::KeyGetLeftDerivative
float KeyGetLeftDerivative(int pIndex)
Get the key left derivative value at the specified index.
kFBLayerModeOverride
@ kFBLayerModeOverride
Layer value will override the value of the other precedent layers.
Definition: fbdata.h:1480
kFBTangentModeTCB
@ kFBTangentModeTCB
TCB spline (3 parameters: TENSION, CONTINUITY, BIAS)
Definition: fbdata.h:145
kFBInterpolationLinear
@ kFBInterpolationLinear
Linear interpolation.
Definition: fbdata.h:120
FBTimeWarpManager::RemoveTimeWarp
void RemoveTimeWarp(FBTake *pTake, FBProperty *pEvalProp)
Undo apply a timeWarp in a Take to an evaluation property, just disconnect the evaluation property fr...
FBFCurveCustomTangentManager::OnCustomKeyChange
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
FB_DEFINE_COMPONENT
FB_DEFINE_COMPONENT(K_DLLIMPORT, AnimationNode)
Animation node class.
kFBFCurveEventTypeDerivativedChanged
@ kFBFCurveEventTypeDerivativedChanged
A key left/right/both derivative was changed, please note that this event can affect the key specifie...
Definition: fbdata.h:1349
kFBFCurveEventTypeKeyTangentConstantChanged
@ kFBFCurveEventTypeKeyTangentConstantChanged
A key constant mode was changed.
Definition: fbdata.h:1354
FBFCurve::KeySetTCBContinuity
void KeySetTCBContinuity(int pIndex, float pValue)
Set the key continuity value at the specified index (TCB key).
FBFCurveKey::Value
FBPropertyFloat Value
Read Write Property: Value of Key
Definition: fbdata.h:262
kFBMergeLayerModeAdditive
@ kFBMergeLayerModeAdditive
The resulting layer will be in additive mode, if possible.
Definition: fbdata.h:1623
FBFCurve::KeyOffset
bool KeyOffset(FBTime &pOffsetTime, FBTime pStartTime=FBTime::MinusInfinity, FBTime pStopTime=FBTime::Infinity, bool pInclusive=true)
Offset keys within a time range by a given offset time.
FBPropertyTimeSpan
class K_DLLIMPORT FBPropertyBase< FBTimeSpan, kFBPT_TimeSpan > FBPropertyTimeSpan
Property: FBTimeSpan
Definition: fbproperties.h:1352
FBFCurve::KeyGetValue
float KeyGetValue(int pIndex)
Get the key value at the specified index.
FBTake::SetLayerRealSelection
void SetLayerRealSelection(bool pValue)
Set real selection for layer.
FBAnimationNode::GetSizeOfData
int GetSizeOfData()
Get sizeof void Data Ptr.
FBPropertyListFCurveKey::RemoveAt
virtual void RemoveAt(int pIndex)
Remove an FCurveKey.
kFBTangentCustomIndex2
@ kFBTangentCustomIndex2
Third custom tangent type registered in the system.
Definition: fbdata.h:201
FBTake::PlotTakeOnObjects
void PlotTakeOnObjects(FBPlotOptions *pPlotOptions, FBArrayTemplate< FBBox * > *pObjectsToPlot)
Plot the animation on given objects.
FBFCurve::KeyOffset
bool KeyOffset(FBTime &pOffsetTime, int pStartIndex, int pStopIndex)
Offset keys within an index range by a given offset time.
FBPropertyListAnimationNode::Add
virtual int Add(FBAnimationNode *pItem)
Add an animation node to the list.
FBFCurveCustomTangentManager::TheOne
static FBFCurveCustomTangentManager & TheOne()
Get the global object for this class.
FBFCurve::KeyGetTangentConstantMode
FBTangentConstantMode KeyGetTangentConstantMode(int pIndex)
Get the key tangent's constant mode at the specified index.
kFBTangentConstantModeNext
@ kFBTangentConstantModeNext
The tangent will contain the value of the next keyframe.
Definition: fbdata.h:168
FBTimeWarpManager::TimeWarpTakeChange
void TimeWarpTakeChange()
Call registered callbacks when changes related to TimeWarp happen.
FBAnimationNode::KeyAdd
void KeyAdd(double *pData, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto)
Add a key to the animation node at current time.
kFBNoChange
@ kFBNoChange
No change to the key.
Definition: fbdata.h:924
FBPropertyEventAnimationNode
PropertyEvent: UI idle event.
Definition: fbdata.h:962
FBAnimationNode::KeyCount
FBPropertyInt KeyCount
Read Only Property: Number of keys.
Definition: fbdata.h:1197
FBTake::AddTimeMark
int AddTimeMark(FBTime pTime, const char *pName=NULL)
Add a time mark to the take.
FBTimeWarpManager::ApplyTimeWarp
bool ApplyTimeWarp(FBTake *pTake, FBProperty *pEvalProp, FBAnimationNode *pTimeWarp)
Apply the TimeWarp in a Take to an evaluation property, just connect the storing property for the Tim...
FBEvaluateInfo
AnimationNodeNotify evaluation information.
Definition: fbevaluateinfo.h:79
FBAnimationNode::GetAnimationToPlay
FBAnimationNode * GetAnimationToPlay()
Get animation node to play from.
FBPropertyListFCurveKey::operator[]
virtual FBFCurveKey operator[](int pIndex)
Overloaded [] operator.
FBFCurveEventManager::OnFCurveEvent
FBFCurveChanged OnFCurveEvent
Event: Called when a registered FCurve is modified.
Definition: fbdata.h:1461
kFBTangentWeightModeRight
@ kFBTangentWeightModeRight
Right tangent weight active.
Definition: fbdata.h:210
FBPropertyString
Property class: const char * (String).
Definition: fbproperties.h:1281
FBFCurve::KeySetTangentClampMode
void KeySetTangentClampMode(int pIndex, FBTangentClampMode pValue)
Set the key tangent's clamp method at the specified index.
FBPropertyListTake::RemoveAt
virtual void RemoveAt(int pIndex) override
Remove the component at pIndex from list.
FBComponent
MotionBuilder SDK base class.
Definition: fbcomponent.h:651
FBAnimationLayer::FBDelete
virtual void FBDelete() override
Virtual FBDelete function.
FBTake::CopyTake
FBTake * CopyTake(const char *pNewTakeName)
Copy the take.
FBFCurve::KeyInsert
void KeyInsert(FBTime &pTime, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto)
Insert a key without affecting the curve shape.
FBFCurve::FBFCurve
FBFCurve(HIObject pObject=NULL)
Constructor.
FBFCurve::KeySetValue
void KeySetValue(int pIndex, float pValue)
Set the key value at the specified index.
FBFCurveCustomTangent::FBFCurveCustomTangent
FBFCurveCustomTangent(HIObject pObject=NULL)
Constructor.
FBTake::FBTake
FBTake(const char *pName, HIObject pObject=NULL)
Constructor.
FBAnimationNode::FCurve
FBPropertyFCurve FCurve
Read Write Property: FCurve for animation.
Definition: fbdata.h:1198
FBAnimationNode::KeyAdd
void KeyAdd(const FBTime &pTime, double *pData, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto)
Add a key to the animation node.
FBCurveCustomKeyAddEvent::KeyIndex
FBPropertyInt KeyIndex
Read Only Property: Index of the new key that will be added
Definition: fbdata.h:911
FBTake::GetLayerByName
FBAnimationLayer * GetLayerByName(const char *pName)
Get the layer object that have the specified name.
FBFCurve::KeyGetTangentClampMode
FBTangentClampMode KeyGetTangentClampMode(int pIndex)
Get the key tangent's clamp method at the specified index.
FBTimeWarpManager::FindTimeWarpNickNumberGlobal
int FindTimeWarpNickNumberGlobal(FBAnimationNode *pTimeWarp)
FBFCurveKey::ExtrapolationMode
FBPropertyExtrapolationMode ExtrapolationMode
Read Write Property: Extrapolation mode
Definition: fbdata.h:282
FBTimeWarpManager::DestroyTimeWarpFromTake
void DestroyTimeWarpFromTake(FBTake *pTake, FBAnimationNode *pTimeWarp)
Destroy the TimeWarp in a Take, and removed from the DataSet.
FBFCurve::EditEnd
void EditEnd(int pKeyCount=-1)
End key adding sequence.
kFBLayerModeOverridePassthrough
@ kFBLayerModeOverridePassthrough
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
FBCurveCustomKeyChangeEvent::KeyIndex
FBPropertyInt KeyIndex
Read Only Property: Index of the key with the custom tangent type.
Definition: fbdata.h:952
FBTimeWarpManager::TimeWarpCreateNew
FBAnimationNode * TimeWarpCreateNew(const char *pName)
FBFCurveKey::TangentMode
FBPropertyTangentMode TangentMode
Read Write Property: Tangent calculation method.
Definition: fbdata.h:277
FBFCurve::EditClear
void EditClear()
Empty FCurve of all keys.
FBSDK_DLL
#define FBSDK_DLL
Be sure that FBSDK_DLL is defined only once...
Definition: fbdata.h:50
FBFCurveEventType
FBFCurveEventType
This enum indicates what modification was made to a tracked FCurve.
Definition: fbdata.h:1343
FBFCurve::KeyDelete
bool KeyDelete(int pStartIndex, int pStopIndex)
Delete keys within an index range.
kFBMergeLayerModeAutomatic
@ kFBMergeLayerModeAutomatic
The resulting layer will be in override mode if one of the source layer is in override,...
Definition: fbdata.h:1622
FBAnimationLayer
Used to access animation layer properties and modify them.
Definition: fbdata.h:1506
FBAnimationNode::WriteGlobalData
bool WriteGlobalData(double *Data, FBEvaluateInfo *pEvaluateInfo)
Write global data to animation node.
FBPropertyListAnimationNode::operator[]
virtual FBAnimationNode * operator[](int pIndex)
Overloaded [] operator.
FBCurveCustomKeyChangeEvent::FBCurveCustomKeyChangeEvent
FBCurveCustomKeyChangeEvent(HKEventBase pEvent)
Constructor.
kFBFCurveEventTypeKeyPostExtrapolationChanged
@ kFBFCurveEventTypeKeyPostExtrapolationChanged
A curve post-extrapolation value was changed.
Definition: fbdata.h:1361
kFBInterpolationInvalid
@ kFBInterpolationInvalid
Invalid interpolation.
Definition: fbdata.h:118
FBFCurveKey::TangentCustomIndex
FBPropertyTangentCustomIndex TangentCustomIndex
Read Write Property: Tangent's custom index
Definition: fbdata.h:283
kFBInterpolationConstant
@ kFBInterpolationConstant
Constant interpolation.
Definition: fbdata.h:119
FBTangentWeightMode
FBTangentWeightMode
Active tangent weight, no/one/both side are active on a key.
Definition: fbdata.h:208
FBAnimationNode::Live
FBPropertyBool Live
Read Write Property: Is animation live?
Definition: fbdata.h:1199