HPropDri.h

Go to the documentation of this file.

// Dan  8/4/2004  \DanLP110\Include\SDK\HPropDri.h

#define __HPROPDRI_H

#ifndef _SMALLPDB

#ifndef __HHASHOBJ_H
#include "HHashObj.h"
#endif

#ifndef __HCP_H
#include "SDK/HCP.h"
#endif

#ifndef __TIMERANG_H
#include "TimeRang.h"
#endif

class HAction;
class HActionCache;
class HDriverShortcut;
class HConstraint;

//*********************************************************
//** HPropertyDriver
//*********************************************************
class PLUGINEXPORT HPropertyDriver : public HHashObject
{
public:
   HProperty *GetProperty();
   
   // A Property can have multiple list of Drivers on them coming from different relationships, Actions, or choractions.
   // Use GetNextActionDriver to get a HeadDriver of a property to get to the next header driver of a different
   // Action applied to the property.
   HPropertyDriver *GetNextActionDriver();

   // Use GetNextDriver to walk through all the drivers for all action applied to
   // the property.
   HPropertyDriver *GetNextDriver();
   
   // GetNextDriverForAction will simply walk all driver applied to the property for
   // the one action
   HPropertyDriver *GetNextDriverForAction(); 
   
   // Action this driver came from
   HAction *GetAction();

   HPropertyDriver *GetDriver(); // Gets the actual driver is this is actually a drivershortcut
   
   BOOL IsSimpleDriverShortcut();
   void SetProperty(HProperty *);
   HDriverShortcut *NewShortcut(HActionCache *);
   int GetNumSubDrivers(); // This is used for Properties like TranslateDriversNoSubs, and BiasDrivers
   HPropertyDriver *GetSubDriverAt( int i ); //This is used for Properties like TranslateDriversNoSubs, and BiasDrivers

   HProperty *FindPropertyFromDriver(BOOL cacheok=FALSE);
   
   HPropertyDriver *MakeCopy();
   void Copy(HPropertyDriver *other);
   void CopyKeys(HPropertyDriver *other, HAction *action=NULL);
   
   HConstraint *IsConstraint();
   BOOL IsStorageDriver();
   
   BOOL AddSelfAppliedDrivers();
};

//*********************************************************
//** HDriverShortcut
//*********************************************************
class PLUGINEXPORT HDriverShortcut : public HPropertyDriver
{
public:
   HPropertyDriver *GetDriver();
   HActionCache *GetActionCache();
};

//*********************************************************
//** HRotateDriverShortcut
//*********************************************************
class PLUGINEXPORT HRotateDriverShortcut : public HDriverShortcut
{
public:
   
   Quaternion GetParentCompensation();
   void SetParentCompensation(Quaternion &quat);
   
   BOOL HasParentCompensation();
   void SetParentCompensation(BOOL state);
};

//*********************************************************
//** HAttrDriver
//*********************************************************
class PLUGINEXPORT HAttrDriver : public HPropertyDriver
{
public:
   static HAttrDriver *New(HProperty *parent);
};

//*********************************************************
//** HBiasDriver
//*********************************************************
class PLUGINEXPORT HBiasDriver : public HPropertyDriver
{
public:
};

//*********************************************************
//** HConstDriver
//*********************************************************
class PLUGINEXPORT HConstDriver : public HPropertyDriver
{
public:
   static HConstDriver *New(HProperty *parent);
   HProperty* GetValue();
};

//*********************************************************
//** HPropertyShortcut
//*********************************************************
class PLUGINEXPORT HPropertyShortcut : public HPropertyDriver
{
public:
   static HPropertyShortcut *New(HProperty *parent);
};

//*********************************************************
//** HFloatDriver
//*********************************************************
class PLUGINEXPORT HFloatDriver : public HPropertyDriver
{
public:
  float GetValue( Time time, TimeRange &validrange );
  float GetValue( Time time );
  void StoreValue( Time time, float value, BOOL storeundo = TRUE );
};

//*********************************************************
//** HChannelDriver
//*********************************************************
class PLUGINEXPORT HChannelDriver : public HFloatDriver
{
public:
   static HChannelDriver *New(HProperty *parent);

   CPInterpolationMethod GetInterpolationMethod() const;
   void SetInterpolationMethod(CPInterpolationMethod);
   
   ExtrapolationMethod GetPreExtrapolationMethod() const;
   void SetPreExtrapolationMethod(ExtrapolationMethod);
   
   ExtrapolationMethod GetPostExtrapolationMethod() const;
   void SetPostExtrapolationMethod(ExtrapolationMethod);
   
   HChannelCP *GetHeadCP();
   HChannelCP *GetTailCP();
   HChannelCP *GetCPFromTime( Time time );
   
   float GetValue( Time time, TimeRange *validrange=NULL );
};

//*********************************************************
//** HTimeBasedKey
//*********************************************************
class HTimeProperty;
class PLUGINEXPORT HTimeBasedKey : public HConstDriver
{
public:
   HTimeProperty *GetTime();
   HTimeBasedKey *GetNextKey();
   HTimeBasedKey *GetPrevKey();
};

//*********************************************************
//** HTimeBasedDriver
//*********************************************************
class PLUGINEXPORT HTimeBasedDriver : public HPropertyDriver
{
public:
   HTimeBasedKey *GetFirstKeyObject();
   HTimeBasedKey *GetLastKeyObject();
   HTimeBasedKey *GetKeyFromTime(Time time);
};

//*********************************************************
//** HRelationMDShortcut
//*********************************************************
class PLUGINEXPORT HRelationMDShortcut : public HPropertyDriver
{
public:
};

//*********************************************************
//** HExpression
//*********************************************************
class PLUGINEXPORT HExpression : public HPropertyDriver
{
public:
   enum { OK, CANTTOKENIZE, NORIGHTPARENTHESIS, UNKNOWNSYMBOL,
    DIVISIONBYZERO, NOLEFTPARENTHESIS, NOCOMMA, OUTOFRANGE, MUSTBEFLOAT,
    BADTYPESFORADD, BADTYPESFORMULTIPLY, INCORRECTTYPE, MUSTBETIME,
    BADTYPESFORCOMPARE, BADTYPESFORAND, BADTYPESFOROR, BADTYPEFORNOT,
    MUSTBEBOOL, MUSTBEVECTOR, MISSINGPARAMETER, MUSTBETRANSFORM }; //error codes
    
   String GetExpressionString();
   int SetExpressionString(const String &str);// returns error code
};

//*********************************************************
//** HRotateDriver
//*********************************************************
class PLUGINEXPORT HRotateDriver : public HPropertyDriver
{
public:
   void ComputeBoneDirections(Vector &bonedir, Vector &rolldir, 
    Vector &parentbonedir, Vector &parentrolldir) const; //Obsolete   
   void ComputeBoneToParent(const Vector &bonedir, const Vector &rolldir, 
    const Vector &parentbonedir, const Vector &parentrolldir); //Obsolete   
   
   Quaternion GetBoneToParent();
   void SetBoneToParent(const Quaternion &quat);

   Quaternion GetParentToBone();
   void SetParentToBone(const Quaternion &quat);
   
   Quaternion GetValue( Time time, TimeRange &validrange );
   Quaternion GetValue( Time time );
   void StoreValue(Time time,  Quaternion &quat, BOOL storeundo=TRUE);
};

//*********************************************************
//** HEulerRotateDriver
//*********************************************************
class PLUGINEXPORT HEulerRotateDriver : public HRotateDriver
{
public:
   static HEulerRotateDriver *New(HProperty *parent);
   RotateEuler GetValue( Time time, TimeRange &validrange );
   RotateEuler GetValue( Time time );
   void StoreValue(Time time, RotateEuler &value, BOOL storeundo=TRUE);

   HFloatDriver *GetX();
   HFloatDriver *GetY();
   HFloatDriver *GetZ();
};

//*********************************************************
//** HQuaternionRotateDriver
//*********************************************************
class PLUGINEXPORT HQuaternionRotateDriver : public HRotateDriver
{
public:
   static HQuaternionRotateDriver *New(HProperty *parent);
   Quaternion GetValue( Time time, TimeRange &validrange );
   Quaternion GetValue( Time time );
   void StoreValue(Time time,  Quaternion &quat, BOOL storeundo=TRUE);
   
   HFloatDriver *GetX();
   HFloatDriver *GetY();
   HFloatDriver *GetZ();
   HFloatDriver *GetW();
};

//*********************************************************
//** HVectorRotateDriver
//*********************************************************
class PLUGINEXPORT HVectorRotateDriver : public HRotateDriver
{
public:
   static HVectorRotateDriver *New(HProperty *parent);
   RotateVector GetValue( Time time, TimeRange &validrange );
   RotateVector GetValue( Time time );
   void StoreValue(Time time, RotateVector &value, BOOL storeundo=TRUE);
   
   HFloatDriver *GetX();
   HFloatDriver *GetY();
   HFloatDriver *GetZ();
   HFloatDriver *GetRoll();
};

//*********************************************************
//** HTransformDriver
//*********************************************************
class PLUGINEXPORT HTransformDriver : public HPropertyDriver
{
public:
   static HTransformDriver *New(HProperty *parent);
};

//*********************************************************
//** HVectorDriverNoSubs
//*********************************************************
class PLUGINEXPORT HVectorDriverNoSubs : public HPropertyDriver
{
public:
   static HVectorDriverNoSubs *New(HProperty *parent);
   Vector GetValue( Time time, TimeRange &validrange );
   Vector GetValue( Time time  );
};

//*********************************************************
//** HTranslateDriverNoSubs
//*********************************************************
class PLUGINEXPORT HTranslateDriverNoSubs : public HVectorDriverNoSubs
{
public:
   static HTranslateDriverNoSubs *New(HProperty *parent);
};

//*********************************************************
//** HVector2Driver
//*********************************************************
class PLUGINEXPORT HVector2Driver : public HPropertyDriver
{
public:
   static HVector2Driver *New(HProperty *parent);
};

#endif

---