{

public:

DECLARE_CLASS_NOBASE( CEventRelativeTag );

enum

{

MAX_EVENTTAG_LENGTH = 128,

};

CEventRelativeTag( CChoreoEvent *owner, const char *name, float percentage );

CEventRelativeTag( const CEventRelativeTag& src );

const char *GetName( void );

float GetPercentage( void );

void SetPercentage( float percentage );

// Returns the corrected time based on the owner's length and start time

float GetStartTime( void );

CChoreoEvent *GetOwner( void );

void SetOwner( CChoreoEvent *event );

protected:

ChoreoStr_t m_Name;

float m_flPercentage;

CChoreoEvent *m_pOwner;

{

public:

enum

{

MAX_EVENTTAG_LENGTH = 128,

};

CEventAbsoluteTag( CChoreoEvent *owner, const char *name, float percentage );

CEventAbsoluteTag( const CEventAbsoluteTag& src );

const char *GetName( void );

float GetPercentage( void );

void SetPercentage( float percentage );

float GetEventTime( void );

void SetEventTime( float t );

float GetAbsoluteTime( void );

void SetAbsoluteTime( float t );

CChoreoEvent *GetOwner( void );

void SetOwner( CChoreoEvent *event );

void SetLocked( bool bLocked );

bool GetLocked( void );

void SetLinear( bool bLinear );

bool GetLinear( void );

void SetEntry( bool bEntry );

bool GetEntry( void );

void SetExit( bool bExit );

bool GetExit( void );

protected:

ChoreoStr_t m_Name;

float m_flPercentage;

bool m_bLocked:1;

bool m_bLinear:1;

bool m_bEntry:1;

bool m_bExit:1;

CChoreoEvent *m_pOwner;

{

DECLARE_CLASS( CFlexTimingTag, CEventRelativeTag );

public:

CFlexTimingTag( CChoreoEvent *owner, const char *name, float percentage, bool locked );

CFlexTimingTag( const CFlexTimingTag& src );

bool GetLocked( void );

void SetLocked( bool locked );

protected:

bool m_bLocked;

{

public:

enum

{

MAX_CONTROLLER_NAME = 128,

};

CFlexAnimationTrack( CChoreoEvent *event );

CFlexAnimationTrack( const CFlexAnimationTrack* src );

virtual ~CFlexAnimationTrack( void );

void SetEvent( CChoreoEvent *event );

CChoreoEvent *GetEvent( void );

void SetFlexControllerName( const char *name );

char const *GetFlexControllerName( void );

void SetComboType( bool combo );

bool IsComboType( void );

void SetMin( float value );

void SetMax( float value );

float GetMin( int type = 0 );

float GetMax( int type = 0 );

bool IsInverted( void );

void SetInverted( bool isInverted );

int GetNumSamples( int type = 0 );

CExpressionSample *GetSample( int index, int type = 0 );

bool IsTrackActive( void );

void SetTrackActive( bool active );

// returns scaled value for absolute time per left/right side

float GetIntensity( float time, int side = 0 );

CExpressionSample *AddSample( float time, float value, int type = 0 );

void RemoveSample( int index, int type = 0 );

void Clear( void );

void Resort( int type = 0 );

// Puts in dummy start/end samples to spline to zero ( or 0.5 for

// left/right data) at the origins

CExpressionSample *GetBoundedSample( int number, bool& bClamped, int type = 0 );

int GetFlexControllerIndex( int side = 0 );

LocalFlexController_t GetRawFlexControllerIndex( int side = 0 );

void SetFlexControllerIndex( LocalFlexController_t raw, int index, int side = 0 );

// returns 0..1 value for 0..1 time fraction per mag/balance

float GetFracIntensity( float time, int type );

// retrieves raw intensity values (for mag vs. left/right slider setting)

float GetSampleIntensity( float time );

float GetBalanceIntensity( float time );

void SetEdgeInfo( bool leftEdge, int curveType, float zero );

void GetEdgeInfo( bool leftEdge, int& curveType, float& zero ) const;

void SetEdgeActive( bool leftEdge, bool state );

bool IsEdgeActive( bool leftEdge ) const;

int GetEdgeCurveType( bool leftEdge ) const;

float GetEdgeZeroValue( bool leftEdge ) const;

float GetDefaultEdgeZeroPos() const;

void SetServerSide( bool state );

bool IsServerSide() const;

private:

// remove any samples after endtime

void RemoveOutOfRangeSamples( int type );

// returns scaled value for absolute time per mag/balance

float GetIntensityInternal( float time, int type );

public:

// returns the fractional (0..1) value for "zero" based on Min/Max ranges

float GetZeroValue( int type, bool leftSide );

private:

char *m_pControllerName;

// base track has range, combo is always 0..1

float m_flMin;

float m_flMax;

// 0 == magnitude

// 1 == left/right

CUtlVector< CExpressionSample > m_Samples[ 2 ];

int m_nFlexControllerIndex[ 2 ];

LocalFlexController_t m_nFlexControllerIndexRaw[ 2 ];

// For left and right edge of type 0 flex data ( magnitude track )

EdgeInfo_t m_EdgeInfo[ 2 ];

CChoreoEvent *m_pEvent;

// Is track active

bool m_bActive:1;

// Is this a combo (magnitude + stereo) track

bool m_bCombo:1;

bool m_bServerSide:1;

bool m_bInverted; // track is displayed 1..0 instead of 0..1

{

public:

// Type of event this object represents

typedef enum

{

// Don't know yet

UNSPECIFIED = 0,

// Section start/end

SECTION,

// Play an expression

EXPRESSION,

// Look at another actor

LOOKAT,

// Move to a location

MOVETO,

// Speak/visemes a wave file

SPEAK,

// Play a gesture

GESTURE,

// Play a sequence

SEQUENCE,

// Face another actor

FACE,

// Fire a trigger

FIRETRIGGER,

// One or more flex sliders animated over the course of the event time period

FLEXANIMATION,

// A contained .vcd file

SUBSCENE,

// Loop back to previous time (forever or up to N times)

LOOP,

// A time span during which the scene may be temporarily interrupted

INTERRUPT,

// A dummy event that is used to mark the .vcd end time

STOPPOINT,

// A time span during which this actor can respond to events happening in the world, etc.

PERMIT_RESPONSES,

// A string passed to the game code for interpretation

GENERIC,

// THIS MUST BE LAST!!!

NUM_TYPES,

} EVENTTYPE;

enum

{

MAX_TAGNAME_STRING = 128,

MAX_CCTOKEN_STRING = 64,

};

typedef enum

{

DEFAULT = 0,

SIMULATION,

DISPLAY,

} TIMETYPE;

typedef enum

{

CC_MASTER = 0, // default, implied

CC_SLAVE,

CC_DISABLED,

NUM_CC_TYPES,

} CLOSECAPTION;

static int s_nGlobalID;

// Construction

CChoreoEvent( CChoreoScene *scene );

CChoreoEvent( CChoreoScene *scene, EVENTTYPE type, const char *name );

CChoreoEvent( CChoreoScene *scene, EVENTTYPE type, const char *name, const char *param );

// Assignment

CChoreoEvent& operator=(const CChoreoEvent& src );

~CChoreoEvent( void );

// ICurveDataAccessor methods

virtual bool CurveHasEndTime();

virtual int GetDefaultCurveType();

// Binary serialization

void SaveToBuffer( CUtlBuffer& buf, CChoreoScene *pScene, IChoreoStringPool *pStringPool );

bool RestoreFromBuffer( CUtlBuffer& buf, CChoreoScene *pScene, IChoreoStringPool *pStringPool );

// Accessors

EVENTTYPE GetType( void );

void SetType( EVENTTYPE type );

void SetName( const char *name );

const char *GetName( void );

void SetParameters( const char *target );

const char *GetParameters( void );

void SetParameters2( const char *target );

const char *GetParameters2( void );

void SetParameters3( const char *target );

const char *GetParameters3( void );

void SetStartTime( float starttime );

float GetStartTime( void );

void SetEndTime( float endtime );

float GetEndTime( void );

float GetDuration( void );

void SetResumeCondition( bool resumecondition );

bool IsResumeCondition( void );

void SetLockBodyFacing( bool lockbodyfacing );

bool IsLockBodyFacing( void );

void SetDistanceToTarget( float distancetotarget );

float GetDistanceToTarget( void );

void SetForceShortMovement( bool bForceShortMovement );

bool GetForceShortMovement( void );

void SetSyncToFollowingGesture( bool bSyncToFollowingGesture );

bool GetSyncToFollowingGesture( void );

void SetPlayOverScript( bool bPlayOverScript );

bool GetPlayOverScript( void );

int GetRampCount( void ) { return m_Ramp.GetCount(); };

CExpressionSample *GetRamp( int index ) { return m_Ramp.Get( index ); };

CExpressionSample *AddRamp( float time, float value, bool selected ) { return m_Ramp.Add( time, value, selected ); };

void DeleteRamp( int index ) { m_Ramp.Delete( index ); };

void ClearRamp( void ) { m_Ramp.Clear(); };

void ResortRamp( void ) { m_Ramp.Resort( this ); };

CCurveData *GetRamp( void ) { return &m_Ramp; };

float GetRampIntensity( float time ) { return m_Ramp.GetIntensity( this, time ); };

// Calculates weighting for a given time

float GetIntensity( float scenetime );

float GetIntensityArea( float scenetime );

// Calculates 0..1 completion for a given time

float GetCompletion( float time );

// An end time of -1.0f means that the events is just triggered at the leading edge

bool HasEndTime( void );

// Is the event something that can be sized ( a wave file, e.g. )

bool IsFixedLength( void );

void SetFixedLength( bool isfixedlength );

// Move the start/end/both times by the specified dt (fixes up -1.0f endtimes)

void OffsetStartTime( float dt );

void OffsetEndTime( float dt );

void OffsetTime( float dt );

// Snap to scene framerate

void SnapTimes( void );

float SnapTime( float t );

CChoreoScene *GetScene( void );

void SetScene( CChoreoScene *scene );

// The actor the event is associated with

void SetActor( CChoreoActor *actor );

CChoreoActor *GetActor( void );

// The channel the event is associated with

void SetChannel( CChoreoChannel *channel );

CChoreoChannel *GetChannel( void );

// Get a more involved description of the event

const char *GetDescription( void );

void ClearAllRelativeTags( void );

int GetNumRelativeTags( void );

CEventRelativeTag *GetRelativeTag( int tagnum );

CEventRelativeTag *FindRelativeTag( const char *tagname );

void AddRelativeTag( const char *tagname, float percentage );

void RemoveRelativeTag( const char *tagname );

bool IsUsingRelativeTag( void );

void SetUsingRelativeTag( bool usetag, const char *tagname = 0, const char *wavname = 0);

const char *GetRelativeTagName( void );

const char *GetRelativeWavName( void );

// Absolute tags

typedef enum

{

PLAYBACK = 0, // new timeline - FIXME: should be stored as an absolute time

ORIGINAL, // original timeline - FIXME: should be stored at a fixed percentage of event

NUM_ABS_TAG_TYPES,

} AbsTagType;

void SetGestureSequenceDuration( float duration );

bool GetGestureSequenceDuration( float& duration );

void ClearAllAbsoluteTags( AbsTagType type );

int GetNumAbsoluteTags( AbsTagType type );

CEventAbsoluteTag *GetAbsoluteTag( AbsTagType type, int tagnum );

CEventAbsoluteTag *FindAbsoluteTag( AbsTagType type, const char *tagname );

void AddAbsoluteTag( AbsTagType type, const char *tagname, float t );

void RemoveAbsoluteTag( AbsTagType type, const char *tagname );

bool VerifyTagOrder( void );

float GetOriginalPercentageFromPlaybackPercentage( float t );

float GetPlaybackPercentageFromOriginalPercentage( float t );

static const char *NameForAbsoluteTagType( AbsTagType t );

static AbsTagType TypeForAbsoluteTagName( const char *name );

void RescaleGestureTimes( float newstart, float newend, bool bMaintainAbsoluteTagPositions );

bool PreventTagOverlap( void );

CEventAbsoluteTag *FindEntryTag( AbsTagType type );

CEventAbsoluteTag *FindExitTag( AbsTagType type );

// Flex animation type

int GetNumFlexAnimationTracks( void );

CFlexAnimationTrack *GetFlexAnimationTrack( int index );

CFlexAnimationTrack *AddTrack( const char *controllername );

CFlexAnimationTrack *FindTrack( const char *controllername );

void RemoveTrack( int index );

void RemoveAllTracks( void );

void OnEndTimeChanged( void );

bool GetTrackLookupSet( void );

void SetTrackLookupSet( bool set );

// Flex Timing Tags (used by editor only)

void ClearAllTimingTags( void );

int GetNumTimingTags( void );

CFlexTimingTag *GetTimingTag( int tagnum );

CFlexTimingTag *FindTimingTag( const char *tagname );

void AddTimingTag( const char *tagname, float percentage, bool locked );

void RemoveTimingTag( const char *tagname );

// Subscene ( embedded .vcd ) support

void SetSubScene( CChoreoScene *scene );

CChoreoScene *GetSubScene( void );

bool IsProcessing( void ) const;

void StartProcessing( IChoreoEventCallback *cb, CChoreoScene *scene, float t );

void ContinueProcessing( IChoreoEventCallback *cb, CChoreoScene *scene, float t );

void StopProcessing( IChoreoEventCallback *cb, CChoreoScene *scene, float t );

bool CheckProcessing( IChoreoEventCallback *cb, CChoreoScene *scene, float t );

void ResetProcessing( void );

void SetMixer( CAudioMixer *mixer );

CAudioMixer *GetMixer( void ) const;

// Hack for LOOKAT in editor

int GetPitch( void ) const;

void SetPitch( int pitch );

int GetYaw( void ) const;

void SetYaw( int yaw );

// For LOOP events

void SetLoopCount( int numloops );

int GetLoopCount( void );

int GetNumLoopsRemaining( void );

void SetNumLoopsRemaining( int loops );

bool IsMarkedForSave() const { return m_bMarkedForSave; }

void SetMarkedForSave( bool mark ) { m_bMarkedForSave = mark; }

void GetMovementStyle( char *style, int maxlen );

void GetDistanceStyle( char *style, int maxlen );

int GetGlobalID() const { return m_nGlobalID; }

// Localization/CC support (close captioning and multiple wave file recombination)

void SetCloseCaptionType( CLOSECAPTION type );

CLOSECAPTION GetCloseCaptionType() const;

void SetCloseCaptionToken( char const *token );

char const *GetCloseCaptionToken() const;

void SetUsingCombinedFile( bool isusing );

bool IsUsingCombinedFile() const;

void SetRequiredCombinedChecksum( unsigned int checksum );

unsigned int GetRequiredCombinedChecksum();

void SetNumSlaves( int num );

int GetNumSlaves() const;

void SetLastSlaveEndTime( float t );

float GetLastSlaveEndTime() const;

void SetCloseCaptionTokenValid( bool valid );

bool GetCloseCaptionTokenValid() const;

bool ComputeCombinedBaseFileName( char *dest, int destlen, bool creategenderwildcard );

bool IsCombinedUsingGenderToken() const;

void SetCombinedUsingGenderToken( bool using_gender );

bool IsSuppressingCaptionAttenuation() const;

void SetSuppressingCaptionAttenuation( bool suppress );

int ValidateCombinedFile();

// This returns false if the wave is CC_DISABLED or is a CC_SLAVE,

// otherwise it returns the actual m_szCCToken value, or if that's

// blank it'll return the sounds.txt entry name (m_szParameters)

bool GetPlaybackCloseCaptionToken( char *dest, int destlen );

void ClearEventDependencies();

void AddEventDependency( CChoreoEvent *other );

void GetEventDependencies( CUtlVector< CChoreoEvent * >& list );

void SetActive( bool state );

bool GetActive() const;

void SetDefaultCurveType( int nCurveType );

// Turn enum into string and vice versa

static EVENTTYPE TypeForName( const char *name );

static const char *NameForType( EVENTTYPE type );

// Turn enum into string and vice versa

static CLOSECAPTION CCTypeForName( const char *name );

static const char *NameForCCType( CLOSECAPTION type );

private:

// Declare copy constructor private to prevent accidental usage...

CChoreoEvent(const CChoreoEvent& src );

void SaveFlexAnimationsToBuffer( CUtlBuffer& buf, IChoreoStringPool *pStringPool );

bool RestoreFlexAnimationsFromBuffer( CUtlBuffer& buf, IChoreoStringPool *pStringPool );

float GetBoundedAbsoluteTagPercentage( AbsTagType type, int tagnum );

float _GetIntensity( float time );

// String bounds

enum

{

MAX_CHOREOEVENT_NAME = 128,

MAX_PARAMETERS_STRING = 128,

};

// Base initialization

void Init( CChoreoScene *scene );

// Type of event

byte m_fType;

// Close caption type

byte m_ccType;

// Name of event

ChoreoStr_t m_Name;

// Event parameters

ChoreoStr_t m_Parameters;

ChoreoStr_t m_Parameters2;

ChoreoStr_t m_Parameters3;

// Event start time

float m_flStartTime;

// Event end time ( -1.0f means no ending, just leading edge triggered )

float m_flEndTime;

// Duration of underlying gesture sequence

float m_flGestureSequenceDuration;

// For CChoreoEvent::LOOP

int m_nNumLoops; // -1 == no limit

int m_nLoopsRemaining;

// Overall intensity curve

CCurveData m_Ramp;

// Start time is computed based on length of item referenced by tagged name

ChoreoStr_t m_TagName;

ChoreoStr_t m_TagWavName;

// Associated actor

CChoreoActor *m_pActor;

// Associated channel

CChoreoChannel *m_pChannel;

CUtlVector < CEventRelativeTag > m_RelativeTags;

CUtlVector < CFlexTimingTag > m_TimingTags;

CUtlVector < CEventAbsoluteTag > m_AbsoluteTags[ NUM_ABS_TAG_TYPES ];

CUtlVector < CFlexAnimationTrack * > m_FlexAnimationTracks;

CChoreoScene *m_pSubScene;

CAudioMixer *m_pMixer;

// Scene which owns this event

CChoreoScene *m_pScene;

int m_nPitch;

int m_nYaw;

float m_flDistanceToTarget;

int m_nGlobalID;

ChoreoStr_t m_CCToken;

unsigned int m_uRequiredCombinedChecksum;

// on master only, the combined file must have the same checksum to be useable

int m_nNumSlaves;

// Only set on master, helps UI draw underbar

float m_flLastSlaveEndTime;

// true if the cc token was found in the cc manager's database

CUtlVector< CChoreoEvent * > m_Dependencies;

int m_nDefaultCurveType;

public:

// used only during scrubbing of looping sequences

float m_flPrevCycle;

float m_flPrevTime;

// Flags

bool m_bFixedLength:1;

// True if this event must be "finished" before the next section can be started

// after playback is paused from a globalevent

bool m_bResumeCondition:1;

bool m_bUsesTag:1;

bool m_bTrackLookupSet:1;

bool m_bProcessing:1;

bool m_bLockBodyFacing:1;

// Purely for save/load

bool m_bMarkedForSave:1;

bool m_bUsingCombinedSoundFile:1;

bool m_bCCTokenValid:1;

bool m_bCombinedUsingGenderToken:1;

bool m_bSuppressCaptionAttenuation:1;

bool m_bForceShortMovement:1;

bool m_bSyncToFollowingGesture:1;

bool m_bActive:1;

bool m_bPlayOverScript:1;