409 lines
12 KiB
C++
409 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef CHOREOSCENE_H
|
|
#define CHOREOSCENE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
class CChoreoEvent;
|
|
class CChoreoChannel;
|
|
class CChoreoActor;
|
|
class IChoreoEventCallback;
|
|
class CEventRelativeTag;
|
|
class CUtlBuffer;
|
|
class CFlexAnimationTrack;
|
|
class ISceneTokenProcessor;
|
|
class IChoreoStringPool;
|
|
|
|
#include "tier1/utlvector.h"
|
|
#include "tier1/utldict.h"
|
|
#include "bitvec.h"
|
|
#include "expressionsample.h"
|
|
#include "choreoevent.h"
|
|
|
|
#define DEFAULT_SCENE_FPS 60
|
|
#define MIN_SCENE_FPS 10
|
|
#define MAX_SCENE_FPS 240
|
|
|
|
#define SCENE_BINARY_TAG MAKEID( 'b', 'v', 'c', 'd' )
|
|
#define SCENE_BINARY_VERSION 0x04
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Container for choreographed scene of events for actors
|
|
//-----------------------------------------------------------------------------
|
|
class CChoreoScene : public ICurveDataAccessor
|
|
{
|
|
typedef enum
|
|
{
|
|
PROCESSING_TYPE_IGNORE = 0,
|
|
PROCESSING_TYPE_START,
|
|
PROCESSING_TYPE_START_RESUMECONDITION,
|
|
PROCESSING_TYPE_CONTINUE,
|
|
PROCESSING_TYPE_STOP,
|
|
} PROCESSING_TYPE;
|
|
|
|
struct ActiveList
|
|
{
|
|
PROCESSING_TYPE pt;
|
|
CChoreoEvent *e;
|
|
};
|
|
|
|
public:
|
|
// Construction
|
|
CChoreoScene( IChoreoEventCallback *callback );
|
|
~CChoreoScene( void );
|
|
|
|
// Assignment
|
|
CChoreoScene& operator=(const CChoreoScene& src );
|
|
|
|
// ICurveDataAccessor methods
|
|
virtual float GetDuration() { return FindStopTime(); };
|
|
virtual bool CurveHasEndTime();
|
|
virtual int GetDefaultCurveType();
|
|
|
|
// Binary serialization
|
|
bool SaveBinary( char const *pszBinaryFileName, char const *pPathID, unsigned int nTextVersionCRC, IChoreoStringPool *pStringPool );
|
|
void SaveToBinaryBuffer( CUtlBuffer& buf, unsigned int nTextVersionCRC, IChoreoStringPool *pStringPool );
|
|
bool RestoreFromBinaryBuffer( CUtlBuffer& buf, char const *filename, IChoreoStringPool *pStringPool );
|
|
static bool GetCRCFromBinaryBuffer( CUtlBuffer& buf, unsigned int& crc );
|
|
|
|
// We do some things differently while restoring from a save.
|
|
inline void SetRestoring( bool bRestoring );
|
|
inline bool IsRestoring();
|
|
|
|
enum
|
|
{
|
|
MAX_SCENE_FILENAME = 128,
|
|
};
|
|
|
|
// Event callback handler
|
|
void SetEventCallbackInterface( IChoreoEventCallback *callback );
|
|
|
|
// Loading
|
|
bool ParseFromBuffer( char const *pFilename, ISceneTokenProcessor *tokenizer );
|
|
void SetPrintFunc( void ( *pfn )( PRINTF_FORMAT_STRING const char *fmt, ... ) );
|
|
|
|
// Saving
|
|
bool SaveToFile( const char *filename );
|
|
bool ExportMarkedToFile( const char *filename );
|
|
void MarkForSaveAll( bool mark );
|
|
|
|
// Merges two .vcd's together, returns true if any data was merged
|
|
bool Merge( CChoreoScene *other );
|
|
|
|
static void FileSaveFlexAnimationTrack( CUtlBuffer& buf, int level, CFlexAnimationTrack *track, int nDefaultCurveType );
|
|
static void FileSaveFlexAnimations( CUtlBuffer& buf, int level, CChoreoEvent *e );
|
|
static void FileSaveRamp( CUtlBuffer& buf, int level, CChoreoEvent *e );
|
|
void FileSaveSceneRamp( CUtlBuffer& buf, int level );
|
|
static void FileSaveScaleSettings( CUtlBuffer& buf, int level, CChoreoScene *scene );
|
|
|
|
static void ParseFlexAnimations( ISceneTokenProcessor *tokenizer, CChoreoEvent *e, bool removeold = true );
|
|
static void ParseRamp( ISceneTokenProcessor *tokenizer, CChoreoEvent *e );
|
|
static void ParseSceneRamp( ISceneTokenProcessor *tokenizer, CChoreoScene *scene );
|
|
static void ParseScaleSettings( ISceneTokenProcessor *tokenizer, CChoreoScene *scene );
|
|
static void ParseEdgeInfo( ISceneTokenProcessor *tokenizer, EdgeInfo_t *edgeinfo );
|
|
|
|
// Debugging
|
|
void SceneMsg( PRINTF_FORMAT_STRING const char *pFormat, ... );
|
|
void Print( void );
|
|
|
|
// Sound system needs to have sounds pre-queued by this much time
|
|
void SetSoundFileStartupLatency( float time );
|
|
|
|
// Simulation
|
|
void Think( float curtime );
|
|
float LoopThink( float curtime );
|
|
void ProcessActiveListEntry( ActiveList *entry );
|
|
// Retrieves time in simulation
|
|
float GetTime( void );
|
|
// Retrieves start/stop time for looped/debug scene
|
|
void GetSceneTimes( float& start, float& end );
|
|
|
|
void SetTime( float t );
|
|
void LoopToTime( float t );
|
|
|
|
// Has simulation finished
|
|
bool SimulationFinished( void );
|
|
// Reset simulation
|
|
void ResetSimulation( bool forward = true, float starttime = 0.0f, float endtime = 0.0f );
|
|
// Find time at which last simulation event is triggered
|
|
float FindStopTime( void );
|
|
|
|
void ResumeSimulation( void );
|
|
|
|
// Have all the pause events happened
|
|
bool CheckEventCompletion( void );
|
|
|
|
// Find named actor in scene data
|
|
CChoreoActor *FindActor( const char *name );
|
|
// Remove actor from scene
|
|
void RemoveActor( CChoreoActor *actor );
|
|
// Find index for actor
|
|
int FindActorIndex( CChoreoActor *actor );
|
|
|
|
// Swap actors in the data
|
|
void SwapActors( int a1, int a2 );
|
|
|
|
// General data access
|
|
int GetNumEvents( void );
|
|
CChoreoEvent *GetEvent( int event );
|
|
|
|
int GetNumActors( void );
|
|
CChoreoActor *GetActor( int actor );
|
|
|
|
int GetNumChannels( void );
|
|
CChoreoChannel *GetChannel( int channel );
|
|
|
|
// Object allocation/destruction
|
|
void DeleteReferencedObjects( CChoreoActor *actor );
|
|
void DeleteReferencedObjects( CChoreoChannel *channel );
|
|
void DeleteReferencedObjects( CChoreoEvent *event );
|
|
|
|
CChoreoActor *AllocActor( void );
|
|
CChoreoChannel *AllocChannel( void );
|
|
CChoreoEvent *AllocEvent( void );
|
|
|
|
void AddEventToScene( CChoreoEvent *event );
|
|
void AddActorToScene( CChoreoActor *actor );
|
|
void AddChannelToScene( CChoreoChannel *channel );
|
|
|
|
// Fixup simulation times for channel gestures
|
|
void ReconcileGestureTimes( void );
|
|
|
|
// Go through all elements and update relative tags, removing any orphaned
|
|
// tags and updating the timestamp of normal tags
|
|
void ReconcileTags( void );
|
|
CEventRelativeTag *FindTagByName( const char *wavname, const char *name );
|
|
CChoreoEvent *FindTargetingEvent( const char *wavname, const char *name );
|
|
|
|
// Used by UI to provide target actor names
|
|
char const *GetMapname( void );
|
|
void SetMapname( const char *name );
|
|
|
|
void ExportEvents( const char *filename, CUtlVector< CChoreoEvent * >& events );
|
|
void ImportEvents( ISceneTokenProcessor *tokenizer, CChoreoActor *actor, CChoreoChannel *channel );
|
|
|
|
// Subscene support
|
|
void SetSubScene( bool sub );
|
|
bool IsSubScene( void ) const;
|
|
|
|
int GetSceneFPS( void ) const;
|
|
void SetSceneFPS( int fps );
|
|
bool IsUsingFrameSnap( void ) const;
|
|
void SetUsingFrameSnap( bool snap );
|
|
|
|
float SnapTime( float t );
|
|
|
|
int GetSceneRampCount( void ) { return m_SceneRamp.GetCount(); };
|
|
CExpressionSample *GetSceneRamp( int index ) { return m_SceneRamp.Get( index ); };
|
|
CExpressionSample *AddSceneRamp( float time, float value, bool selected ) { return m_SceneRamp.Add( time, value, selected ); };
|
|
void DeleteSceneRamp( int index ) { m_SceneRamp.Delete( index ); };
|
|
void ClearSceneRamp( void ) { m_SceneRamp.Clear(); };
|
|
void ResortSceneRamp( void ) { m_SceneRamp.Resort( this ); };
|
|
|
|
CCurveData *GetSceneRamp( void ) { return &m_SceneRamp; };
|
|
|
|
|
|
// Global intensity for scene
|
|
float GetSceneRampIntensity( float time ) { return m_SceneRamp.GetIntensity( this, time ); }
|
|
|
|
int GetTimeZoom( char const *tool );
|
|
void SetTimeZoom( char const *tool, int tz );
|
|
int TimeZoomFirst();
|
|
int TimeZoomNext( int i );
|
|
int TimeZoomInvalid() const;
|
|
char const *TimeZoomName( int i );
|
|
|
|
void ReconcileCloseCaption();
|
|
|
|
char const *GetFilename() const;
|
|
void SetFileName( char const *fn );
|
|
|
|
bool GetPlayingSoundName( char *pchBuff, int iBuffLength );
|
|
bool HasUnplayedSpeech();
|
|
bool HasFlexAnimation();
|
|
void SetBackground( bool bIsBackground );
|
|
bool IsBackground( void );
|
|
|
|
void ClearPauseEventDependencies();
|
|
|
|
bool HasEventsOfType( CChoreoEvent::EVENTTYPE type ) const;
|
|
void RemoveEventsExceptTypes( int* typeList, int count );
|
|
|
|
void IgnorePhonemes( bool bIgnore );
|
|
bool ShouldIgnorePhonemes() const;
|
|
|
|
// This is set by the engine to signify that we're not modifying the data and
|
|
// therefore we can precompute the end time
|
|
static bool s_bEditingDisabled;
|
|
|
|
private:
|
|
|
|
// Simulation stuff
|
|
enum
|
|
{
|
|
IN_RANGE = 0,
|
|
BEFORE_RANGE,
|
|
AFTER_RANGE
|
|
};
|
|
|
|
int IsTimeInRange( float t, float starttime, float endtime );
|
|
|
|
static bool EventLess( const CChoreoScene::ActiveList &al0, const CChoreoScene::ActiveList &al1 );
|
|
|
|
int EventThink( CChoreoEvent *e,
|
|
float frame_start_time,
|
|
float frame_end_time,
|
|
bool playing_forward, PROCESSING_TYPE& disposition );
|
|
|
|
// Prints to debug console, etc
|
|
void choreoprintf( int level, PRINTF_FORMAT_STRING const char *fmt, ... );
|
|
|
|
// Initialize scene
|
|
void Init( IChoreoEventCallback *callback );
|
|
|
|
float FindAdjustedStartTime( void );
|
|
float FindAdjustedEndTime( void );
|
|
|
|
CChoreoEvent *FindPauseBetweenTimes( float starttime, float endtime );
|
|
|
|
// Parse scenes from token buffer
|
|
CChoreoEvent *ParseEvent( CChoreoActor *actor, CChoreoChannel *channel );
|
|
CChoreoChannel *ParseChannel( CChoreoActor *actor );
|
|
CChoreoActor *ParseActor( void );
|
|
|
|
void ParseFPS( void );
|
|
void ParseSnap( void );
|
|
void ParseIgnorePhonemes( void );
|
|
|
|
// Map file for retrieving named objects
|
|
void ParseMapname( void );
|
|
// When previewing actor in hlfaceposer, this is the model to associate
|
|
void ParseFacePoserModel( CChoreoActor *actor );
|
|
|
|
// Print to printfunc
|
|
void PrintEvent( int level, CChoreoEvent *e );
|
|
void PrintChannel( int level, CChoreoChannel *c );
|
|
void PrintActor( int level, CChoreoActor *a );
|
|
|
|
// File I/O
|
|
public:
|
|
static void FilePrintf( CUtlBuffer& buf, int level, PRINTF_FORMAT_STRING const char *fmt, ... );
|
|
private:
|
|
void FileSaveEvent( CUtlBuffer& buf, int level, CChoreoEvent *e );
|
|
void FileSaveChannel( CUtlBuffer& buf, int level, CChoreoChannel *c );
|
|
void FileSaveActor( CUtlBuffer& buf, int level, CChoreoActor *a );
|
|
void FileSaveHeader( CUtlBuffer& buf );
|
|
|
|
// Object destruction
|
|
void DestroyActor( CChoreoActor *actor );
|
|
void DestroyChannel( CChoreoChannel *channel );
|
|
void DestroyEvent( CChoreoEvent *event );
|
|
|
|
|
|
void AddPauseEventDependency( CChoreoEvent *pauseEvent, CChoreoEvent *suppressed );
|
|
|
|
void InternalDetermineEventTypes();
|
|
|
|
// Global object storage
|
|
CUtlVector < CChoreoEvent * > m_Events;
|
|
CUtlVector < CChoreoActor * > m_Actors;
|
|
CUtlVector < CChoreoChannel * > m_Channels;
|
|
|
|
// These are just pointers, the actual objects are in m_Events
|
|
CUtlVector < CChoreoEvent * > m_ResumeConditions;
|
|
// These are just pointers, the actual objects are in m_Events
|
|
CUtlVector < CChoreoEvent * > m_ActiveResumeConditions;
|
|
// These are just pointers, the actual objects are in m_Events
|
|
CUtlVector < CChoreoEvent * > m_PauseEvents;
|
|
|
|
// Current simulation time
|
|
float m_flCurrentTime;
|
|
|
|
float m_flStartLoopTime;
|
|
|
|
float m_flStartTime;
|
|
float m_flEndTime;
|
|
|
|
float m_flEarliestTime;
|
|
float m_flLatestTime;
|
|
int m_nActiveEvents;
|
|
|
|
// Wave file playback needs to issue play commands a bit ahead of time
|
|
// in order to hit exact marks
|
|
float m_flSoundSystemLatency;
|
|
|
|
// Scene's linger a bit after finishing to let blends reset themselves
|
|
float m_flLastActiveTime;
|
|
|
|
// Print callback function
|
|
void ( *m_pfnPrint )( PRINTF_FORMAT_STRING const char *fmt, ... );
|
|
|
|
IChoreoEventCallback *m_pIChoreoEventCallback;
|
|
|
|
ISceneTokenProcessor *m_pTokenizer;
|
|
|
|
enum
|
|
{
|
|
MAX_MAPNAME = 128
|
|
};
|
|
|
|
char m_szMapname[ MAX_MAPNAME ];
|
|
|
|
int m_nSceneFPS;
|
|
|
|
CCurveData m_SceneRamp;
|
|
|
|
CUtlDict< int, int > m_TimeZoomLookup;
|
|
char m_szFileName[ MAX_SCENE_FILENAME ];
|
|
|
|
CBitVec< CChoreoEvent::NUM_TYPES > m_bitvecHasEventOfType;
|
|
|
|
// tag to suppress vcd when others are playing
|
|
bool m_bIsBackground : 1;
|
|
bool m_bIgnorePhonemes : 1;
|
|
bool m_bSubScene : 1;
|
|
bool m_bUseFrameSnap : 1;
|
|
bool m_bRestoring : 1;
|
|
|
|
int m_nLastPauseEvent;
|
|
// This only gets updated if it's loaded from a buffer which means we're not in an editor
|
|
float m_flPrecomputedStopTime;
|
|
};
|
|
|
|
|
|
bool CChoreoScene::IsRestoring()
|
|
{
|
|
return m_bRestoring;
|
|
}
|
|
|
|
|
|
void CChoreoScene::SetRestoring( bool bRestoring )
|
|
{
|
|
m_bRestoring = bRestoring;
|
|
}
|
|
|
|
|
|
abstract_class IChoreoStringPool
|
|
{
|
|
public:
|
|
virtual short FindOrAddString( const char *pString ) = 0;
|
|
virtual bool GetString( short stringId, char *buff, int buffSize ) = 0;
|
|
};
|
|
|
|
CChoreoScene *ChoreoLoadScene(
|
|
char const *filename,
|
|
IChoreoEventCallback *callback,
|
|
ISceneTokenProcessor *tokenizer,
|
|
void ( *pfn ) ( PRINTF_FORMAT_STRING const char *fmt, ... ) );
|
|
|
|
bool IsBufferBinaryVCD( char *pBuffer, int bufferSize );
|
|
|
|
#endif // CHOREOSCENE_H
|