1HEADmaster

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