source: golgotha/src/maxtool/sdk_inc/animtbl.h @ 80 Tweet

/**********************************************************************
 *<
        FILE:  animtbl.h

        DESCRIPTION:  Defines Animatable Classes

        CREATED BY: Rolf Berteig & Dan Silva

        HISTORY: created 9 September 1994

 *>     Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/

#ifndef _ANIMTBL_H_
#define _ANIMTBL_H_


#define ANIMTYPE_NODE           1
#define ANIMTYPE_ROOTNODE       3
#define ANIMTYPE_CONTROL        2

/*---------------------------------------------------*/

class TreeListExp; 
class AnimEnum;
class ReferenceTarget;
class DWORDTab;
class IObjParam;
class INodeTab;
class AppDataChunk;

// Values for flags in aflag
#define A_EVALUATING            1
#define A_NOTIFYDEP             (1<<1)
#define A_CHILD_TREE_OPEN       (1<<2)
#define A_SUBANIM_TREE_OPEN     (1<<3)
#define A_OBJECT_REDUCED        (1<<4)

// BITS 5-11 are reserved for specific sub-class use.

// Atmospheric flags
#define A_ATMOS_DISABLED        (1<<5)

// OBJECT flags
#define A_OBJ_CREATING          (1<<5)          // The object is being created. It doesn't want to snap to itself.

// MODIFIER flags . 
#define A_MOD_DISABLED          (1<<5)     // Modifier flag
#define A_MOD_BEING_EDITED      (1<<6)
#define A_MOD_USE_SEL           (1<<7)     // Modifier flag (use sub-ob selection)

// MODAPP flags. 
#define A_MODAPP_DISABLED               (1<<5)  // ModApp flag
#define A_MODAPP_SELECTED               (1<<6)  // ModApp flag (parent node is selected)
#define A_MODAPP_DISPLAY_ACTIVE (1<<7)  // ModApp flag
#define A_MODAPP_DYNAMIC_BOX    (1<<8)  // ModApp flag

// Derived Object Flags
#define A_DERIVEDOBJ_DONTDELETE (1<<9)  // When the last modifier is deleted form this derived object, don't delete the derived object

// CONTROL flags
#define A_ORT_MASK                              7
#define A_ORT_BEFORESHIFT               5       // Uses bit 5,6,7,8,9 and 10 to store ORT
#define A_ORT_AFTERSHIFT                8
#define A_CTRL_DISABLED                 (1<<11)
#define A_ORT_DISABLED                  A_SUPERCLASS1  // indicates that the ORT is disabled

// INODE flags
#define A_INODE_IK_TERMINATOR   (1<<5)  // Terminates the top of an IK chain
#define A_INODE_IK_POS_PINNED   (1<<6)
#define A_INODE_IK_ROT_PINNED   (1<<7)


// Flags for Hold and Restore logic, for "lazy holding",
// to avoid multiple holding.
#define A_HELD                          (1<<12)
#define A_SET                           (1<<13)

// Deleted but kept around for UNDO
#define A_IS_DELETED            (1<<14)

// To prevent AutoDelete from being re-entered.
#define A_BEING_AUTO_DELETED  (1<<15)

// Reserved for superclass use
#define A_SUPERCLASS1           (1<<20)
#define A_SUPERCLASS2           (1<<21)

// These are reserved for use by the plug-in. No should will set these flags (except the plug-in class itself)
#define A_PLUGIN1                       (1<<22)
#define A_PLUGIN2                       (1<<23)
#define A_PLUGIN3                       (1<<24)
#define A_PLUGIN4                       (1<<25)

// Used to test for a dependency
#define A_DEPENDENCY_TEST       (1<<26)

// Ref target isn't deleted when dependents goes to 0 if this flag is set.
#define A_LOCK_TARGET           (1<<27)

#define A_WORK1                         (1<<28)
#define A_WORK2                         (1<<29)
#define A_WORK3                         (1<<30)
#define A_WORK4                         (1<<31)

#define A_OPENFLAG(t) ((t==0)?A_CHILD_TREE_OPEN:A_SUBANIM_TREE_OPEN)


class TimeMap {
        public:
                virtual TimeValue map(TimeValue t)=0;
                virtual TimeValue prevmap(TimeValue t)=0;
        };

class TrackHitRecord  {
        public:
                DWORD   hit;
                DWORD   flags;
                TrackHitRecord(DWORD h=0,DWORD f=0) {hit=h;flags=f;}
        };
typedef Tab<TrackHitRecord> TrackHitTab;


// Flags passed to MapKeys and DeleteKeys
#define TRACK_DOSEL                     (1<<0)
#define TRACK_DOALL                     (1<<1)  // ignore selection
#define TRACK_SLIDEUNSEL        (1<<2)  // Slide unselected keys to the right
#define TRACK_RIGHTTOLEFT       (1<<3)  // Enumerate right to left. If TRACK_SLIDEUNSEL is set, keys will slide to the left.
#define TRACK_DOSUBANIMS        (1<<4)  // This flag is only passed to MapKeys
#define TRACK_DOCHILDNODES      (1<<5)  // This flag is only passed to MapKeys
#define TRACK_MAPRANGE          (1<<6)  // The range, if not locked to first and last key, should be mapped as well.

// Flags passed to EditTimeRange
#define EDITRANGE_LINKTOKEYS    (1<<0)  // This means if one of the ends of the interval is at a key, link it to the key so that if the key moves, the interval moves.

// Flags passed to hit test tracks and fcurves.
#define HITTRACK_SELONLY                (1<<0)
#define HITTRACK_UNSELONLY              (1<<1)
#define HITTRACK_ABORTONHIT             (1<<2)
#define HITCURVE_TESTTANGENTS   (1<<3)


// Flags passed to SelectKeys
// Either SELECT, DESELECT, or a combination of CLEARKEYS and CLEARCURVE
// will be specified.
#define SELKEYS_SELECT                  (1<<0)  
#define SELKEYS_DESELECT                (1<<1)
#define SELKEYS_CLEARKEYS               (1<<2)           
#define SELKEYS_CLEARCURVE              (1<<3) 
#define SELKEYS_FCURVE                  (1<<4)  // indicates that were operating on keys of a function curve, not a track  


// Flags passed to GetTimeRange
#define TIMERANGE_SELONLY               (1<<0)  // The bounding interval of selected keys
#define TIMERANGE_ALL                   (1<<1)  // Whatever the channel's time range is - usually the bunding interval of all keys.
#define TIMERANGE_CHILDNODES    (1<<2)  // A node's time range should include child nodes.
#define TIMERANGE_CHILDANIMS    (1<<3)  // A animatable's child anim ranges should be included

// Passed to the functions that modify a time range such as copy,paste,delete,reverse
#define TIME_INCLEFT            (1<<10)  // Include left endpoint
#define TIME_INCRIGHT           (1<<11)  // Include right endpoint
#define TIME_NOSLIDE            (1<<12)  // Delete any keys in the interval but don't actually remove the block of time.

// In addition to the TIME_ flags above, the following flag may be passed to PasteTrck()
#define PASTE_RELATIVE          (1<<20) // Add the keys relative to existing keys

// Flags passed to AddKey
#define ADDKEY_SELECT           (1<<0)  // Select the new key and deselect any other selected keys
#define ADDKEY_INTERP           (1<<1)  // Init the new key to the interpolated value at that time. Otherwise, init the key to the value of the previous key.
#define ADDKEY_FLAGGED          (1<<2)  // Flag the newly created key as if FlagKey() was called for it

// Flags passed to CopyKeysFromTime()
#define COPYKEY_POS                     (1<<0)  // These filter flags are passed to a tm controller. The tm
#define COPYKEY_ROT                     (1<<1)  // can decide what to do with them... they have obvious meaning
#define COPYKEY_SCALE           (1<<2)  // For the PRS controller.

// Flags passed to GetNextKeyTime()
#define NEXTKEY_LEFT            (1<<0)  // Search to the left.
#define NEXTKEY_RIGHT           (1<<1)  // Search to the right.
#define NEXTKEY_POS                     (1<<2)
#define NEXTKEY_ROT                     (1<<3)
#define NEXTKEY_SCALE           (1<<4)

// Flags passed to IsKeyAtTime
#define KEYAT_POSITION          (1<<0)
#define KEYAT_ROTATION          (1<<1)
#define KEYAT_SCALE                     (1<<2)

// Flags passed to PaintTrack and PaintFCurves
#define PAINTTRACK_SHOWSEL                      (1<<0)
#define PAINTTRACK_SHOWSTATS            (1<<1)  // Show for selected keys
#define PAINTCURVE_SHOWTANGENTS         (1<<2)  // Show for selected keys
#define PAINTCURVE_FROZEN                       (1<<3)  // Curve is in a frozen state

// Flags passed to GetFCurveExtents
#define EXTENTS_SHOWTANGENTS            (1<<0) // Tangents are visible for selected keys


// Values returned from PaintTrack and HitTestTrack
#define TRACK_DONE                      1               // Track was successfully painted/hittested
#define TRACK_DORANGE           2               // This anim has no track. Draw/hittest the bounding range of it's subanims

// Values returned from HitTestFCurve
#define HITCURVE_KEY            1       // Hit one or more keys
#define HITCURVE_WHOLE          2   // Hit the curve (anywhere)
#define HITCURVE_TANGENT        3       // Hit a tangent handle
#define HITCURVE_NONE           4       // Didn't hit squat

// These flags are passed into PaintFCurves, HitTestFCurves, and GetFCurveExtnents
// They are filters for controllers with more than one curve
// NOTE: RGB controllers interpret X as red, Y as green and Z as blue.
#define DISPLAY_XCURVE          (1<<29)
#define DISPLAY_YCURVE          (1<<30)
#define DISPLAY_ZCURVE          (1<<31)

// Values returned from GetSelKeyCoords()
#define KEYS_NONESELECTED       (1<<0)
#define KEYS_MULTISELECTED      (1<<1)
#define KEYS_COMMONTIME         (1<<2)  // Both of these last two bits
#define KEYS_COMMONVALUE        (1<<3)  // could be set.

// Flags passed to GetSelKeyCoords()
#define KEYCOORDS_TIMEONLY              (1<<0)
#define KEYCOORDS_VALUEONLY             (1<<1)

// Returned from NumKeys() if the animatable is not keyframeable
#define NOT_KEYFRAMEABLE        -1

// Flags passed to AdjustTangents
#define ADJTAN_LOCK             (1<<0)
#define ADJTAN_BREAK    (1<<1)

// Flags passed to EditTrackParams
#define EDITTRACK_FCURVE        (1<<0)  // The user is in the function curve editor.
#define EDITTRACK_TRACK         (1<<1)  // The user is in one of the track views.
#define EDITTRACK_SCENE         (1<<2)  // The user is editing a path in the scene.
#define EDITTRACK_BUTTON        (1<<3)  // The user invoked by choosing the properties button. In this case the time parameter is NOT valid.
#define EDITTRACK_MOUSE         (1<<4)  // The user invoked by right clicking with the mouse. In this case the time parameter is valid.


// These are returned from TrackParamsType(). They define how the track parameters are invoked.
#define TRACKPARAMS_NONE        0       // Has no track parameters
#define TRACKPARAMS_KEY         1       // Entered by right clicking on a selected key
#define TRACKPARAMS_WHOLE       2       // Entered by right clicking anywhere in the track.


// Macros for converting track screen coords to time and back.
#define TimeToScreen(t,scale,scroll) (int(floor((t)*(scale)+0.5)) - (scroll))
#define ScreenToTime(s,scale,scroll) ((int)floor((s)/(scale) + (scroll)/(scale)+0.5))
#define ValueToScreen(v,h,scale,scroll) (h-int(floor((v)*(scale)+0.5)) - (scroll))
#define ScreenToValue(s,h,scale,scroll) ((float(h)-(float(s)+float(scroll)))/(scale))

// Scales a value about an origin
#define ScaleAboutOrigin(val,origin,scale) ((((val)-(origin))*(scale))+(origin))


class TrackClipObject {
        public:
                // Specifies the interval of time clipped.
                Interval clip;          

                // Identifies the creator of the clip object
                virtual SClass_ID       SuperClassID()=0;
                virtual Class_ID        ClassID()=0;

                TrackClipObject(Interval iv) {clip = iv;}
                virtual void DeleteThis()=0;
        };


// This must be updated if a new entry is added to DimType!
#define NUM_BUILTIN_DIMS        10

enum DimType {
        DIM_WORLD,
        DIM_ANGLE,
        DIM_COLOR,              //0-1
        DIM_COLOR255,   //0-255
        DIM_PERCENT,    //0-100
        DIM_NORMALIZED, //0-1
        DIM_SEGMENTS,
        DIM_TIME,
        DIM_CUSTOM,
        DIM_NONE
        };

// These two classes describes the dimension of a parameter (sub-anim).
// The dimension type and possibly the dimension scale (if the type is
// custom) are used to determine a scale factor for the parameter.
// When a controller is drawing a function curve, it only needs to
// use the Convert() function - the scale factor is rolled into the single
// 'vzoom' parameter passed to PaintFCurves.
// So, for a controller to plot a value 'val' at time t it would do the
// following:
// int x = TimeToScreen(t,tzoom,tscroll);
// int y = ValueToScreen(dim->Convert(val),rect.h()-1,vzoom,vscroll);
//
class ParamDimensionBase {
        public:
                virtual DimType DimensionType()=0;
                virtual float Convert(float value)=0;
                virtual float UnConvert(float value)=0;
        }; 
class ParamDimension : public ParamDimensionBase {
        public:
                // If the DimType is custom than these must be implemented.
                virtual float GetDimScale() {return 1.0f;}
                virtual void SetDimScale() {}
                virtual TCHAR *DimensionName() {return _T("");}         
        };

// These point to default implementations for the standard DIM types.
CoreExport extern ParamDimension *defaultDim;
CoreExport extern ParamDimension *stdWorldDim;
CoreExport extern ParamDimension *stdAngleDim;
CoreExport extern ParamDimension *stdColorDim;
CoreExport extern ParamDimension *stdColor255Dim;
CoreExport extern ParamDimension *stdPercentDim;
CoreExport extern ParamDimension *stdNormalizedDim;
CoreExport extern ParamDimension *stdSegmentsDim;
CoreExport extern ParamDimension *stdTimeDim;

// Interface IDs for GetInterface() - NOTE: doesn't need to be released.
#define I_CONTROL                       0x00001001              
#define I_MASTER                        0x00001010
#define I_EASELIST                      0x00001020
#define I_MULTLIST                      0x00001030
#define I_BASEOBJECT            0x00001040
#define I_PARTICLEOBJ           0x00001050
#define I_KEYCONTROL            0x00001060
#define I_TEXTOBJECT            0x00001070
#define I_WAVESOUND                     0x00001080

// Plug-in defined interfaces should be > this id
#define I_USERINTERFACE         0x0000ffff

        
#define GetControlInterface(anim)       ((Control*)anim->GetInterface(I_CONTROL))
#define GetObjectInterface(anim)        ((BaseObject*)anim->GetInterface(I_BASEOBJECT))
#define GetParticleInterface(anim)      ((ParticleObject*)anim->GetInterface(I_PARTICLEOBJ))
#define GetKeyControlInterface(anim) ((IKeyControl*)anim->GetInterface(I_KEYCONTROL))
#define GetMasterController(anim) ((ReferenceTarget*)anim->GetInterface(I_MASTER))
#define GetTextObjectInterface(anim) ((ITextObject*)anim->GetInterface(I_TEXTOBJECT))
#define GetWaveSoundInterface(anim) ((IWaveSound*)anim->GetInterface(I_WAVESOUND))


// This is the base class for classes that can be hung off an animatable's
// property list. When an animatable is deleted, it's properties will be
// deleted and their virtual destructor will be called.
class AnimProperty {
        public:
                virtual BOOL DontDelete() {return FALSE;}
                virtual ~AnimProperty() {}
                virtual DWORD ID()=0;
        };

class AnimPropertyList : public Tab<AnimProperty*> {
        public:
                CoreExport int FindProperty(DWORD id,int start=0);
        };


// Property IDs
#define PROPID_APPDATA          0x00000010
#define PROPID_EASELIST         0x00000020
#define PROPID_MULTLIST         0x00000030
#define PROPID_NOTETRACK        0x00000040
#define PROPID_USER                     0x0000FFFF      
// Values above PROPID_USER can be used by plug-ins. 
// Note: that a plug-in should only put user defined properties on it's
// own list. So IDs only have to be unique within a plug-in. If a plug-in
// needs to attach data to another object, it can do so via APP_DATA.

// BeginEditParams flags values
#define BEGIN_EDIT_CREATE               (1<<0)
#define BEGIN_EDIT_MOTION               (1<<1)  // Controller is being edited in the motion branch
#define BEGIN_EDIT_HIERARCHY    (1<<2)  // Same as BEGIN_EDIT_IK
#define BEGIN_EDIT_IK                   (1<<2)  // Controller is being edited in the IK subtask of the hierarchy branch
#define BEGIN_EDIT_LINKINFO             (1<<3)  // Controller is being edited in the Link Info  subtask of the hierarchy branch

// EndEditParams flags values
#define END_EDIT_REMOVEUI  (1<<0)

// Flags passed to EnumAuxFiles
#define FILE_ENUM_INACTIVE              (1<<0)                  // enumerate inactive files
#define FILE_ENUM_VP                    (1<<1)                  // enumerate video post files
#define FILE_ENUM_RENDER                (1<<2)                  // enumerate render files 
#define FILE_ENUM_ALL  (FILE_ENUM_INACTIVE|FILE_ENUM_VP|FILE_ENUM_RENDER)       // enumerate ALL files
#define FILE_ENUM_MISSING_ONLY  (1<<8)                  // enumerate missing files only
#define FILE_ENUM_1STSUB_MISSING (1<<9)             // just enumerate 1st file named by ifl if missing

// To enumerate all active but missing files
#define FILE_ENUM_MISSING_ACTIVE (FILE_ENUM_VP|FILE_ENUM_RENDER|FILE_ENUM_MISSING_ONLY)

// To enumerate all active but missing files, but only enumerate first subfile pointed
// to by an ifl (enumerating all of them can be very slow).
#define FILE_ENUM_MISSING_ACTIVE1 (FILE_ENUM_MISSING_ACTIVE|FILE_ENUM_1STSUB_MISSING )

// A callback object passed to EnumAuxFiles().
class NameEnumCallback {
        public:
                virtual void RecordName(TCHAR *name)=0;
        };

class NoteTrack;

class Animatable {
                friend class ISaveImp;
                friend class ILoadImp;

        protected:
                unsigned long aflag;
                AnimPropertyList aprops;

        public: 
                void SetAFlag(int mask) { aflag|=mask; }
                void ClearAFlag(int mask) { aflag &= ~mask; }
                int TestAFlag(int mask) { return(aflag&mask?1:0); }
                Animatable() { aflag = 0; }             
                Animatable& operator=(const Animatable& an)  { aflag = an.aflag; return *this; }                
                virtual void GetClassName(TSTR& s) { s= TSTR(_T("Animatable")); }  
                CoreExport virtual Class_ID ClassID();
                CoreExport virtual SClass_ID SuperClassID();            
                CoreExport virtual ~Animatable();

                // This is how things are actually deleted. 
                // Since they are created with the ClassDesc::Create()  function, and 
                // deleted via this function, they can use a different memory allocator
                // than the core code. (theoretically)
                CoreExport virtual void DeleteThis();
                
                // Get rid of anything that can be rebuilt 
                // Objects have a default implementation.
                virtual void FreeCaches() {}

                // 'create' is TRUE if parameters are being edited in the create branch.
                // 'removeUI' is TRUE if the object's UI should be removed.
                virtual void BeginEditParams(IObjParam *ip,ULONG flags,Animatable *prev=NULL) {} 
                virtual void EndEditParams(IObjParam *ip,ULONG flags,Animatable *next=NULL) {} 

                // OLE-like method for adding new interfaces
                virtual void* GetInterface(ULONG id) { return NULL; }
                virtual void ReleaseInterface(ULONG id,void *i) {}

                // General method for adding properties, when
                // defining a new Interface would be too cumbersome
                virtual int SetProperty(ULONG id, void *data) { return 0; }
                virtual void *GetProperty(ULONG id) { return NULL; }

                virtual int NumSubs()  { return 0; }     // How many sub-animatables are there?
                virtual Animatable* SubAnim(int i) { return NULL; }  // access the ith sub-animatable
                CoreExport virtual TSTR SubAnimName(int i);  // get name of ith subanim
                virtual BOOL BypassTreeView() { return FALSE; } // return TRUE and you won't appear in the TreeView however your children will.
                virtual BOOL AssignController(Animatable *control,int subAnim) {return FALSE;}
                
                // Converts an anim index to a ref index or returns -1 if there is no
                // corrispondance. This is used for copying and pasting in the track
                // view. If a client does not wish an anim to be copy/pastable then
                // it can return -1 even if there is a corrisponding ref num.
                virtual int SubNumToRefNum(int subNum) {return -1;}

                // In addition to SubNumToRefNum(), if an anim doesn't want to be coppied it can return FALSE from this function
                virtual BOOL CanCopyAnim() {return TRUE;}

                // An anim can implement this to reutrn FALSE to prohibit make unique
                virtual BOOL CanMakeUnique() {return TRUE;}

                virtual int NumChildren() {return 0; }   // Non-zero only for nodes.
                virtual Animatable* ChildAnim(int i) { return NULL; } // access the ith child
                CoreExport virtual TSTR NodeName();        // For nodes only

                CoreExport int EnumAnimTree(AnimEnum *animEnum, Animatable *client, int subNum);
                CoreExport int HasSubElements(int type=0);              

                // called once at the beginning of each render
                virtual int RenderBegin(TimeValue t, ULONG flags=0) { return 0; }
                // called once at the end of each render
                virtual int RenderEnd(TimeValue t) { return 0; }

                // edit the track or parameters
                virtual void EditTrack() { assert(0); } 
                
                // Get the number of keys and the time of the ith key.
                virtual int NumKeys() {return NOT_KEYFRAMEABLE;}
                virtual TimeValue GetKeyTime(int index) {return 0;}
                virtual int GetKeyIndex(TimeValue t) {return -1;}
                virtual BOOL GetNextKeyTime(TimeValue t,DWORD flags,TimeValue &nt) {return FALSE;}
                virtual void CopyKeysFromTime(TimeValue src,TimeValue dst,DWORD flags) {} 
                virtual void DeleteKeyAtTime(TimeValue t) {}
                virtual BOOL IsKeyAtTime(TimeValue t,DWORD flags) {return FALSE;}
                
                // The value returned from these two methods should be the number of keys skipped because their times were before
                // range.Start(). So sel[i] is the selection state for the offset+ith key.
                virtual int GetKeyTimes(Tab<TimeValue> &times,Interval range,DWORD flags) {return 0;}           
                virtual int GetKeySelState(BitArray &sel,Interval range,DWORD flags) {return 0;}

                // TreeView Methods
                /////////////////////////////////////////////////////////////
                void OpenTreeEntry(int type) {SetAFlag(A_OPENFLAG(type));}
                void CloseTreeEntry(int type) {ClearAFlag(A_OPENFLAG(type));}
                CoreExport int IsTreeEntryOpen(int type);
                
                // The tracks time range:
                CoreExport virtual Interval GetTimeRange(DWORD flags);
                virtual void EditTimeRange(Interval range,DWORD flags) {};
                
                // Operations to a selected block of time               
                virtual void DeleteTime(Interval iv, DWORD flags) {}
                virtual void ReverseTime(Interval iv, DWORD flags) {}
                virtual void ScaleTime(Interval iv, float s) {}
                virtual void InsertTime(TimeValue ins, TimeValue amount) {}
                
                // If an anim supports the above time operations it should return TRUE from this method.
                // Returning TRUE enables time selection on the track view for the track.
                virtual BOOL SupportTimeOperations() {return FALSE;}

                // Operations to keys
                CoreExport virtual void MapKeys(TimeMap *map, DWORD flags);
                virtual void DeleteKeys(DWORD flags) {}
                virtual void DeleteKeyByIndex(int index) {}
                virtual void SelectKeys(TrackHitTab& sel, DWORD flags) {}
                virtual void FlagKey(TrackHitRecord hit) {}
                virtual int GetFlagKeyIndex() {return -1;}
                virtual int NumSelKeys() {return 0;}
                virtual void CloneSelectedKeys(BOOL offset=FALSE) {}   // When offset is TRUE, set the new key time to be centered between the original key and the next key
                virtual void AddNewKey(TimeValue t,DWORD flags) {}
                virtual void MoveKeys(ParamDimensionBase *dim,float delta,DWORD flags) {}  // move selected keys vertically in the function curve editor
                virtual void ScaleKeyValues(ParamDimensionBase *dim,float origin,float scale,DWORD flags) {}
                virtual void SelectCurve(BOOL sel) {}
                virtual BOOL IsCurveSelected() {return FALSE;}
                virtual BOOL IsKeySelected(int index) {return FALSE;}
                virtual int GetSelKeyCoords(TimeValue &t, float &val,DWORD flags) {return KEYS_NONESELECTED;}
                virtual void SetSelKeyCoords(TimeValue t, float val,DWORD flags) {}
                virtual void AdjustTangents(
                        TrackHitRecord hit,
                        ParamDimensionBase *dim,
                        Rect& rcGraph,
                        float tzoom,
                        int tscroll,
                        float vzoom,
                        int vscroll,
                        int dx,int dy,
                        DWORD flags) {};

                // Does this animatable actually have animation?
                // Default implementation returns TRUE if a child anim has animation.
                CoreExport virtual BOOL IsAnimated(); 

                // Clipboard methods:
                virtual BOOL CanCopyTrack(Interval iv, DWORD flags) {return FALSE;}
                virtual BOOL CanPasteTrack(TrackClipObject *cobj,Interval iv, DWORD flags) {return FALSE;}
                virtual TrackClipObject *CopyTrack(Interval iv, DWORD flags) {return NULL;}
                virtual void PasteTrack(TrackClipObject *cobj,Interval iv, DWORD flags) {}

                // Drawing and hit testing tracks
                virtual int GetTrackVSpace( int lineHeight ) { return 1; }
                virtual int HitTestTrack(                       
                        TrackHitTab& hits,
                        Rect& rcHit,
                        Rect& rcTrack,                  
                        float zoom,
                        int scroll,
                        DWORD flags ) { return TRACK_DORANGE; }
                virtual int PaintTrack(                 
                        HDC hdc,
                        Rect& rcTrack,
                        Rect& rcPaint,
                        float zoom,
                        int scroll,
                        DWORD flags ) { return TRACK_DORANGE; }
                
                // Drawing and hit testing function curves
                virtual int PaintFCurves(                       
                        ParamDimensionBase *dim,
                        HDC hdc,
                        Rect& rcGraph,
                        Rect& rcPaint,
                        float tzoom,
                        int tscroll,
                        float vzoom,
                        int vscroll,
                        DWORD flags ) { return 0; }
                virtual int HitTestFCurves(                     
                        ParamDimensionBase *dim,
                        TrackHitTab& hits,
                        Rect& rcHit,
                        Rect& rcGraph,                  
                        float tzoom,
                        int tscroll,
                        float vzoom,
                        int vscroll,
                        DWORD flags ) { return HITCURVE_NONE; }
                
                // Edit key info (or whatever) for selected keys.
                // hParent is the parent window that should be used to create any dialogs.
                // This function should not return until the user has completed editng at which
                // time any windows that were created should be destroyed. Unlike
                // BeginEditParams/EndEditParams this interface is modal.               
                virtual void EditTrackParams(
                        TimeValue t,    // The horizontal position of where the user right clicked.
                        ParamDimensionBase *dim,
                        TCHAR *pname, // The name of the parameter as given by the client
                        HWND hParent,
                        IObjParam *ip,
                        DWORD flags) {}

                // Returns a value indicating how track parameters are
                // are invoked. See description above by
                // TRACKPARAMS_NONE, TRACKPARAMS_KEY, TRACKPARAMS_WHOLE
                virtual int TrackParamsType() {return TRACKPARAMS_NONE;}

                // Calculate the largest and smallest values.
                // If this is processed, return non-zero.
                virtual int GetFCurveExtents(
                        ParamDimensionBase *dim,
                        float &min, float &max, DWORD flags) {return 0;}
                
                // Describes the type of dimension of the ith sub-anim
                virtual ParamDimension* GetParamDimension(int i) {return defaultDim;}

                // This is not used anymore.
                virtual LRESULT CALLBACK TrackViewWinProc( HWND hwnd,  UINT message, 
                                                           WPARAM wParam, LPARAM lParam ) { return 0;}


                // Add/delete note tracks
                CoreExport void AddNoteTrack(NoteTrack *note);
                CoreExport void DeleteNoteTrack(NoteTrack *note,BOOL delNote=TRUE); // If delNote is FALSE the note track will be removed from the anim but not deleted.
                CoreExport BOOL HasNoteTracks();
                CoreExport int NumNoteTracks();
                CoreExport NoteTrack *GetNoteTrack(int i);

                // Enumerate auxiliary files -- see ref.h for default implementation
                virtual void EnumAuxFiles(NameEnumCallback& nameEnum, DWORD flags = FILE_ENUM_ALL) {}

                // A master controller should implement this method to give the 
                // MAX a list of nodes that are part of the system. 
                virtual void GetSystemNodes(INodeTab &nodes) {}

                // If an object is a sub-class of a particular class, it will have a
                // different ClassID() because it is a different class. This method
                // allows an object to indicate that it is a sub-class of a particluar
                // class and therefore can be treated as one.
                // For example, a class could be derived from TriObject. This derived
                // class would have a different ClassID() then TriObject's class ID
                // however it still can be treated (cast) as a TriObject because it
                // is derived from TriObject.
                // Note the default implelementation: a class is considered to also
                // be a subclass of itself.
                virtual BOOL IsSubClassOf(Class_ID classID) {return classID==ClassID();}

                // Access app data chunks
                CoreExport void AddAppDataChunk(Class_ID cid, SClass_ID sid, DWORD sbid, DWORD len, void *d);
                CoreExport AppDataChunk *GetAppDataChunk(Class_ID cid, SClass_ID sid, DWORD sbid);
                CoreExport BOOL RemoveAppDataChunk(Class_ID cid, SClass_ID sid, DWORD sbid);            
        };





//
// Callback for EnumAnimTree:
//
// Scope values:

#define SCOPE_DOCLOSED 1                // do "closed" animatables.
#define SCOPE_SUBANIM  2                // do the sub anims 
#define SCOPE_CHILDREN 4                // do the node children
#define SCOPE_OPEN      (SCOPE_SUBANIM|SCOPE_CHILDREN) // do all open animatables
#define SCOPE_ALL       (SCOPE_OPEN|SCOPE_DOCLOSED)     // do all animatables

// Return values for AnimEnum procs
#define ANIM_ENUM_PROCEED 1
#define ANIM_ENUM_STOP 2
#define ANIM_ENUM_ABORT 3

class AnimEnum {
        protected:
                int depth;
                int scope;  
        public:
                AnimEnum(int s = SCOPE_OPEN, int deep = 0) { scope = s; depth = deep; }
                void SetScope(int s) { scope = s; }
                int Scope() { return scope; }
                void IncDepth() { depth++; }
                void DecDepth() { depth--; }
                int Depth() { return depth; }
                virtual int proc(Animatable *anim, Animatable *client, int subNum)=0;
        };

// A usefule enumeration
class ClearAnimFlagEnumProc : public AnimEnum {
                DWORD flag;
        public:
                ClearAnimFlagEnumProc(DWORD f) {flag=f;}
                int proc(Animatable *anim, Animatable *client, int subNum) {
                        anim->ClearAFlag(flag);
                        return ANIM_ENUM_PROCEED;
                        }
        };


//
// The is used by the two functions GetSubObjectCenters() and
// GetSubObjectTMs() found in the classes BaseObject and Control.
//
class SubObjAxisCallback {
        public:
                virtual void Center(Point3 c,int id)=0;
                virtual void TM(Matrix3 tm,int id)=0;
                virtual int Type()=0;
        };

// Values returned by Type();
#define SO_CENTER_SELECTION     1 
#define SO_CENTER_PIVOT         2


// --- AppData ---------------------------------------------

// An individual app data chunk
class AppDataChunk {
        public:
                // Note that data pointer should be allocated with standard malloc
                // since it will be freed in the destructor.
                AppDataChunk(Class_ID cid, SClass_ID sid, DWORD sbid, DWORD len, void *d)
                        {classID=cid; superClassID=sid; subID=sbid; length=len; data=d;}
                AppDataChunk() {length=0;data=NULL;}

                ~AppDataChunk() {
                        if (data) free(data);
                        }               

                // The super class and class IDs of the object that
                // is the owner of this chunk.
                Class_ID  classID;
                SClass_ID superClassID;

                // An extra ID that lets the owner identify its sub chunks.
                DWORD subID;
                
                // The chunk data itself
                DWORD length;
                void *data;

                // IO
                CoreExport IOResult Load(ILoad *iload);
                CoreExport IOResult Save(ISave *isave);
        };


// This list is maintained by the systems. Plug-ins need not concern themselves with it.
class AnimAppData : public AnimProperty {
        public:                         
                Tab<AppDataChunk*> chunks;
                CRITICAL_SECTION csect;
                AppDataChunk *lastSearch;

                DWORD ID() {return PROPID_APPDATA;}             
                CoreExport ~AnimAppData();
                CoreExport AnimAppData();

                CoreExport AppDataChunk *FindChunk(Class_ID cid, SClass_ID sid, DWORD sbid);
                void AddChunk(AppDataChunk *newChunk) {chunks.Append(1,&newChunk);}
                CoreExport BOOL RemoveChunk(Class_ID cid, SClass_ID sid, DWORD sbid);

                CoreExport IOResult Load(ILoad *iload);
                CoreExport IOResult Save(ISave *isave);
        };

 
CoreExport void SetLockFailureLevel(int level);
CoreExport int GetLockFailureLevel();

class Interface;
CoreExport Interface *GetCOREInterface();


// This API allows plug-in to query various system settings.
// At the moment the only setting available is the enabled state
// fo reditable meshes.
#define SYSSET_ENABLE_EDITABLEMESH              1

CoreExport int GetSystemSetting(int id);

// Returns the state of the VERSION_3DSMAX #define from PLUGAPI.H
// when the running version of MAX was compiled.
CoreExport DWORD Get3DSMAXVersion();


#endif // _ANIMTBL_H_