diff options
Diffstat (limited to 'game/shared/choreoevent.h')
| -rw-r--r-- | game/shared/choreoevent.h | 708 |
1 files changed, 708 insertions, 0 deletions
diff --git a/game/shared/choreoevent.h b/game/shared/choreoevent.h new file mode 100644 index 0000000..ad4828d --- /dev/null +++ b/game/shared/choreoevent.h @@ -0,0 +1,708 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef CHOREOEVENT_H +#define CHOREOEVENT_H +#ifdef _WIN32 +#pragma once +#endif + +class CChoreoActor; +class CChoreoChannel; +class CChoreoEvent; +class CChoreoScene; +class IChoreoEventCallback; +class CAudioMixer; +class CUtlBuffer; +class IChoreoStringPool; + + +#include "tier1/utlstring.h" +#include "tier1/utlvector.h" +#include "expressionsample.h" +#include "networkvar.h" +#include "localflexcontroller.h" + +typedef CUtlString ChoreoStr_t; + +//----------------------------------------------------------------------------- +// Purpose: SPEAK events can have "relative tags" that other objects can reference +// to specify their start times off of +//----------------------------------------------------------------------------- +class CEventRelativeTag +{ +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; +}; + +//----------------------------------------------------------------------------- +// Purpose: GESTURE events can have "absolute tags" (where the value is not a +// percentage, but an actual timestamp from the start of the event) +//----------------------------------------------------------------------------- +class CEventAbsoluteTag +{ +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; +}; + +//----------------------------------------------------------------------------- +// Purpose: FLEXANIMATION events can have "timing tags" that are used to align and +// manipulate flex animation curves +//----------------------------------------------------------------------------- +class CFlexTimingTag : public CEventRelativeTag +{ + 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; +}; + +//----------------------------------------------------------------------------- +// Purpose: A flex controller position can be animated over a period of time +//----------------------------------------------------------------------------- +class CFlexAnimationTrack +{ +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 +}; + + +//----------------------------------------------------------------------------- +// Purpose: The generic scene event type +//----------------------------------------------------------------------------- +class CChoreoEvent : public ICurveDataAccessor +{ +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; +}; + +#endif // CHOREOEVENT_H |