709 lines
20 KiB
C++
709 lines
20 KiB
C++
//========= 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
|