658 lines
16 KiB
C++
658 lines
16 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include <mxtk/mx.h>
|
|
#include <stdio.h>
|
|
#include "resource.h"
|
|
#include "EventProperties.h"
|
|
#include "mdlviewer.h"
|
|
#include "choreoevent.h"
|
|
#include "choreoscene.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "choreochannel.h"
|
|
#include "choreoactor.h"
|
|
#include "filesystem.h"
|
|
#include "scriplib.h"
|
|
|
|
#include "eventproperties_expression.h"
|
|
#include "eventproperties_face.h"
|
|
#include "eventproperties_firetrigger.h"
|
|
#include "eventproperties_flexanimation.h"
|
|
#include "eventproperties_generic.h"
|
|
#include "eventproperties_gesture.h"
|
|
#include "eventproperties_interrupt.h"
|
|
#include "eventproperties_lookat.h"
|
|
#include "eventproperties_moveto.h"
|
|
#include "eventproperties_permitresponses.h"
|
|
#include "eventproperties_sequence.h"
|
|
#include "eventproperties_speak.h"
|
|
#include "eventproperties_subscene.h"
|
|
|
|
void CBaseEventPropertiesDialog::PopulateTagList( CEventParams *params )
|
|
{
|
|
CChoreoScene *scene = params->m_pScene;
|
|
if ( !scene )
|
|
return;
|
|
|
|
HWND control = GetControl( IDC_TAGS );
|
|
if ( control )
|
|
{
|
|
SendMessage( control, CB_RESETCONTENT, 0, 0 );
|
|
SendMessage( control, WM_SETTEXT , 0, (LPARAM)va( "\"%s\" \"%s\"", params->m_szTagName, params->m_szTagWav ) );
|
|
|
|
for ( int i = 0; i < scene->GetNumActors(); i++ )
|
|
{
|
|
CChoreoActor *a = scene->GetActor( i );
|
|
if ( !a )
|
|
continue;
|
|
|
|
for ( int j = 0; j < a->GetNumChannels(); j++ )
|
|
{
|
|
CChoreoChannel *c = a->GetChannel( j );
|
|
if ( !c )
|
|
continue;
|
|
|
|
for ( int k = 0 ; k < c->GetNumEvents(); k++ )
|
|
{
|
|
CChoreoEvent *e = c->GetEvent( k );
|
|
if ( !e )
|
|
continue;
|
|
|
|
if ( e->GetNumRelativeTags() <= 0 )
|
|
continue;
|
|
|
|
// add each tag to combo box
|
|
for ( int t = 0; t < e->GetNumRelativeTags(); t++ )
|
|
{
|
|
CEventRelativeTag *tag = e->GetRelativeTag( t );
|
|
if ( !tag )
|
|
continue;
|
|
|
|
SendMessage( control, CB_ADDSTRING, 0, (LPARAM)va( "\"%s\" \"%s\"", tag->GetName(), e->GetParameters() ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#include "mapentities.h"
|
|
#include "utldict.h"
|
|
|
|
struct CMapEntityData
|
|
{
|
|
CMapEntityData()
|
|
{
|
|
origin.Init();
|
|
angles.Init();
|
|
}
|
|
|
|
Vector origin;
|
|
QAngle angles;
|
|
};
|
|
|
|
class CMapEntities : public IMapEntities
|
|
{
|
|
public:
|
|
CMapEntities();
|
|
~CMapEntities();
|
|
|
|
virtual void CheckUpdateMap( char const *mapname );
|
|
virtual bool LookupOrigin( char const *name, Vector& origin, QAngle& angles )
|
|
{
|
|
int idx = FindNamedEntity( name );
|
|
if ( idx == -1 )
|
|
{
|
|
origin.Init();
|
|
angles.Init();
|
|
return false;
|
|
}
|
|
|
|
CMapEntityData *e = &m_Entities[ idx ];
|
|
Assert( e );
|
|
origin = e->origin;
|
|
angles = e->angles;
|
|
return true;
|
|
}
|
|
|
|
virtual int Count( void );
|
|
virtual char const *GetName( int number );
|
|
|
|
int FindNamedEntity( char const *name );
|
|
|
|
private:
|
|
char m_szCurrentMap[ 1024 ];
|
|
|
|
CUtlDict< CMapEntityData, int > m_Entities;
|
|
};
|
|
|
|
static CMapEntities g_MapEntities;
|
|
// Expose to rest of tool
|
|
IMapEntities *mapentities = &g_MapEntities;
|
|
|
|
CMapEntities::CMapEntities()
|
|
{
|
|
m_szCurrentMap[ 0 ] = 0;
|
|
}
|
|
|
|
CMapEntities::~CMapEntities()
|
|
{
|
|
m_Entities.RemoveAll();
|
|
}
|
|
|
|
int CMapEntities::FindNamedEntity( char const *name )
|
|
{
|
|
char lowername[ 128 ];
|
|
strcpy( lowername, name );
|
|
_strlwr( lowername );
|
|
|
|
int index = m_Entities.Find( lowername );
|
|
if ( index == m_Entities.InvalidIndex() )
|
|
return -1;
|
|
|
|
return index;
|
|
}
|
|
|
|
#include "bspfile.h"
|
|
|
|
void CMapEntities::CheckUpdateMap( char const *mapname )
|
|
{
|
|
if ( !mapname || !mapname[ 0 ] )
|
|
return;
|
|
|
|
if ( !stricmp( mapname, m_szCurrentMap ) )
|
|
return;
|
|
|
|
// Latch off the name of the map
|
|
Q_strncpy( m_szCurrentMap, mapname, sizeof( m_szCurrentMap ) );
|
|
|
|
// Load names from map
|
|
m_Entities.RemoveAll();
|
|
|
|
FileHandle_t hfile = filesystem->Open( mapname, "rb" );
|
|
if ( hfile == FILESYSTEM_INVALID_HANDLE )
|
|
return;
|
|
|
|
dheader_t header;
|
|
filesystem->Read( &header, sizeof( header ), hfile );
|
|
|
|
// Check the header
|
|
if ( header.ident != IDBSPHEADER ||
|
|
header.version < MINBSPVERSION || header.version > BSPVERSION )
|
|
{
|
|
Con_ErrorPrintf( "BSP file %s is wrong version (%i), expected (%i)\n",
|
|
mapname,
|
|
header.version,
|
|
BSPVERSION );
|
|
|
|
filesystem->Close( hfile );
|
|
return;
|
|
}
|
|
|
|
// Find the LUMP_PAKFILE offset
|
|
lump_t *entlump = &header.lumps[ LUMP_ENTITIES ];
|
|
if ( entlump->filelen <= 0 )
|
|
{
|
|
Con_ErrorPrintf( "BSP file %s is missing entity lump\n", mapname );
|
|
|
|
// It's empty or only contains a file header ( so there are no entries ), so don't add to search paths
|
|
filesystem->Close( hfile );
|
|
return;
|
|
}
|
|
|
|
// Seek to correct position
|
|
filesystem->Seek( hfile, entlump->fileofs, FILESYSTEM_SEEK_HEAD );
|
|
|
|
char *buffer = new char[ entlump->filelen + 1 ];
|
|
Assert( buffer );
|
|
|
|
filesystem->Read( buffer, entlump->filelen, hfile );
|
|
|
|
filesystem->Close( hfile );
|
|
|
|
buffer[ entlump->filelen ] = 0;
|
|
|
|
// Now we have entity buffer, now parse it
|
|
ParseFromMemory( buffer, entlump->filelen );
|
|
|
|
while ( 1 )
|
|
{
|
|
if (!GetToken (true))
|
|
break;
|
|
|
|
if (Q_stricmp (token, "{") )
|
|
Error ("ParseEntity: { not found");
|
|
|
|
char name[ 256 ];
|
|
char origin[ 256 ];
|
|
char angles[ 256 ];
|
|
|
|
name[ 0 ] = 0;
|
|
origin[ 0 ] = 0;
|
|
angles[ 0 ] = 0;
|
|
|
|
do
|
|
{
|
|
char key[ 256 ];
|
|
char value[ 256 ];
|
|
|
|
if (!GetToken (true))
|
|
{
|
|
Error ("ParseEntity: EOF without closing brace");
|
|
}
|
|
|
|
if (!Q_stricmp (token, "}") )
|
|
break;
|
|
|
|
Q_strncpy( key, token, sizeof( key ) );
|
|
|
|
GetToken (false);
|
|
|
|
Q_strncpy( value, token, sizeof( value ) );
|
|
|
|
// Con_Printf( "Parsed %s -- %s\n", key, value );
|
|
|
|
if ( !Q_stricmp( key, "name" ) )
|
|
{
|
|
Q_strncpy( name, value, sizeof( name ) );
|
|
}
|
|
if ( !Q_stricmp( key, "targetname" ) )
|
|
{
|
|
Q_strncpy( name, value, sizeof( name ) );
|
|
}
|
|
if ( !Q_stricmp( key, "origin" ) )
|
|
{
|
|
Q_strncpy( origin, value, sizeof( origin ) );
|
|
}
|
|
if ( !Q_stricmp( key, "angles" ) )
|
|
{
|
|
Q_strncpy( angles, value, sizeof( angles ) );
|
|
}
|
|
|
|
} while (1);
|
|
|
|
if ( name[ 0 ] )
|
|
{
|
|
if ( FindNamedEntity( name ) == - 1 )
|
|
{
|
|
CMapEntityData ent;
|
|
|
|
float org[3];
|
|
if ( origin[ 0 ] )
|
|
{
|
|
if ( 3 == sscanf( origin, "%f %f %f", &org[ 0 ], &org[ 1 ], &org[ 2 ] ) )
|
|
{
|
|
ent.origin = Vector( org[ 0 ], org[ 1 ], org[ 2 ] );
|
|
|
|
// Con_Printf( "read %f %f %f for entity %s\n", org[0], org[1], org[2], name );
|
|
}
|
|
}
|
|
if ( angles[ 0 ] )
|
|
{
|
|
if ( 3 == sscanf( angles, "%f %f %f", &org[ 0 ], &org[ 1 ], &org[ 2 ] ) )
|
|
{
|
|
ent.angles = QAngle( org[ 0 ], org[ 1 ], org[ 2 ] );
|
|
|
|
// Con_Printf( "read %f %f %f for entity %s\n", org[0], org[1], org[2], name );
|
|
}
|
|
}
|
|
|
|
m_Entities.Insert( name, ent );
|
|
}
|
|
}
|
|
}
|
|
|
|
delete[] buffer;
|
|
}
|
|
|
|
int CMapEntities::Count( void )
|
|
{
|
|
return m_Entities.Count();
|
|
}
|
|
|
|
char const *CMapEntities::GetName( int number )
|
|
{
|
|
if ( number < 0 || number >= (int)m_Entities.Count() )
|
|
return NULL;
|
|
|
|
return m_Entities.GetElementName( number );
|
|
}
|
|
|
|
bool NameLessFunc( const char *const& name1, const char *const& name2 )
|
|
{
|
|
if ( Q_stricmp( name1, name2 ) < 0 )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CBaseEventPropertiesDialog::SetDialogTitle( CEventParams *params, char const *eventname, char const *desc )
|
|
{
|
|
char sz[ 256 ];
|
|
Q_snprintf( sz, sizeof( sz ), " : %s", eventname );
|
|
Q_strncat( params->m_szDialogTitle, sz, sizeof( params->m_szDialogTitle ), COPY_ALL_CHARACTERS );
|
|
Q_snprintf( sz, sizeof( sz ), "%s:", desc );
|
|
|
|
// Set dialog title
|
|
SetWindowText( m_hDialog, params->m_szDialogTitle );
|
|
// Set type name field
|
|
SetDlgItemText( m_hDialog, IDC_TYPENAME, sz );
|
|
// Set event name
|
|
SetDlgItemText( m_hDialog, IDC_EVENTNAME, params->m_szName );
|
|
}
|
|
|
|
void CBaseEventPropertiesDialog::ShowControlsForEventType( CEventParams *params )
|
|
{
|
|
// Special processing for various settings
|
|
if ( !params->m_bHasEndTime )
|
|
{
|
|
ShowWindow( GetControl( IDC_ENDTIME ), SW_HIDE );
|
|
}
|
|
|
|
if ( params->m_bFixedLength )
|
|
{
|
|
ShowWindow( GetControl( IDC_ENDTIME ), SW_HIDE );
|
|
ShowWindow( GetControl( IDC_CHECK_ENDTIME ), SW_HIDE );
|
|
}
|
|
}
|
|
|
|
void CBaseEventPropertiesDialog::InitControlData( CEventParams *params )
|
|
{
|
|
SetDlgItemText( m_hDialog, IDC_STARTTIME, va( "%f", params->m_flStartTime ) );
|
|
SetDlgItemText( m_hDialog, IDC_ENDTIME, va( "%f", params->m_flEndTime ) );
|
|
|
|
SendMessage( GetControl( IDC_CHECK_ENDTIME ), BM_SETCHECK,
|
|
( WPARAM ) params->m_bHasEndTime ? BST_CHECKED : BST_UNCHECKED,
|
|
( LPARAM )0 );
|
|
|
|
if ( GetControl( IDC_CHECK_RESUMECONDITION ) != (HWND)0 )
|
|
{
|
|
SendMessage( GetControl( IDC_CHECK_RESUMECONDITION ), BM_SETCHECK,
|
|
( WPARAM ) params->m_bResumeCondition ? BST_CHECKED : BST_UNCHECKED,
|
|
( LPARAM )0 );
|
|
}
|
|
|
|
SendMessage( GetControl( IDC_CHECK_DISABLED ), BM_SETCHECK,
|
|
( WPARAM ) params->m_bDisabled ? BST_CHECKED : BST_UNCHECKED,
|
|
( LPARAM )0 );
|
|
|
|
PopulateTagList( params );
|
|
}
|
|
|
|
BOOL CBaseEventPropertiesDialog::InternalHandleMessage( CEventParams *params, HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam, bool& handled )
|
|
{
|
|
handled = false;
|
|
switch(uMsg)
|
|
{
|
|
default:
|
|
break;
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
default:
|
|
break;
|
|
case IDC_CHECK_DISABLED:
|
|
{
|
|
params->m_bDisabled = SendMessage( GetControl( IDC_CHECK_DISABLED ), BM_GETCHECK, 0, 0 ) == BST_CHECKED ? true : false;
|
|
handled = true;
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void CBaseEventPropertiesDialog::PopulateNamedActorList( HWND wnd, CEventParams *params )
|
|
{
|
|
int i;
|
|
|
|
char const *mapname = NULL;
|
|
if ( params->m_pScene )
|
|
{
|
|
mapname = params->m_pScene->GetMapname();
|
|
}
|
|
|
|
CUtlRBTree< char const *, int > m_SortedNames( 0, 0, NameLessFunc );
|
|
|
|
if ( mapname )
|
|
{
|
|
g_MapEntities.CheckUpdateMap( mapname );
|
|
|
|
for ( i = 0; i < g_MapEntities.Count(); i++ )
|
|
{
|
|
char const *name = g_MapEntities.GetName( i );
|
|
if ( name && name[ 0 ] )
|
|
{
|
|
m_SortedNames.Insert( name );
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( i = 0 ; i < params->m_pScene->GetNumActors() ; i++ )
|
|
{
|
|
CChoreoActor *actor = params->m_pScene->GetActor( i );
|
|
if ( actor && actor->GetName() && actor->GetName()[0] )
|
|
{
|
|
if ( m_SortedNames.Find( actor->GetName() ) == m_SortedNames.InvalidIndex() )
|
|
{
|
|
m_SortedNames.Insert( actor->GetName() );
|
|
}
|
|
}
|
|
}
|
|
|
|
i = m_SortedNames.FirstInorder();
|
|
while ( i != m_SortedNames.InvalidIndex() )
|
|
{
|
|
char const *name = m_SortedNames[ i ];
|
|
if ( name && name[ 0 ] )
|
|
{
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)name );
|
|
}
|
|
|
|
i = m_SortedNames.NextInorder( i );
|
|
}
|
|
|
|
/*
|
|
// Note have to do this here, after posting data to the control, since we are storing a raw string pointer in m_SortedNames!!!
|
|
if ( allActors )
|
|
{
|
|
allActors->deleteThis();
|
|
}
|
|
*/
|
|
|
|
// These events can also be directed at another player or named target, too
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!player" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!enemy" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!self" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!friend" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!speechtarget" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target1" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target2" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target3" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target4" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target5" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target6" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target7" );
|
|
SendMessage( wnd, CB_ADDSTRING, 0, (LPARAM)"!target8" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : wnd -
|
|
// *params -
|
|
// Output : static void
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseEventPropertiesDialog::ParseTags( CEventParams *params )
|
|
{
|
|
strcpy( params->m_szTagName, "" );
|
|
strcpy( params->m_szTagWav, "" );
|
|
|
|
if ( params->m_bUsesTag )
|
|
{
|
|
// Parse out the two tokens
|
|
char selectedText[ 512 ];
|
|
selectedText[ 0 ] = 0;
|
|
HWND control = GetControl( IDC_TAGS );
|
|
if ( control )
|
|
{
|
|
SendMessage( control, WM_GETTEXT, (WPARAM)sizeof( selectedText ), (LPARAM)selectedText );
|
|
}
|
|
|
|
ParseFromMemory( selectedText, strlen( selectedText ) );
|
|
if ( TokenAvailable() )
|
|
{
|
|
GetToken( false );
|
|
char tagname[ 256 ];
|
|
strcpy( tagname, token );
|
|
if ( TokenAvailable() )
|
|
{
|
|
GetToken( false );
|
|
char wavename[ 256 ];
|
|
strcpy( wavename, token );
|
|
|
|
// Valid
|
|
strcpy( params->m_szTagName, tagname );
|
|
strcpy( params->m_szTagWav, wavename );
|
|
|
|
}
|
|
else
|
|
{
|
|
params->m_bUsesTag = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
params->m_bUsesTag = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : wnd -
|
|
// *params -
|
|
// Output : static void
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseEventPropertiesDialog::UpdateTagRadioButtons( CEventParams *params )
|
|
{
|
|
if ( params->m_bUsesTag )
|
|
{
|
|
SendMessage( GetControl( IDC_RELATIVESTART ), BM_SETCHECK, ( WPARAM )BST_CHECKED, (LPARAM)0 );
|
|
SendMessage( GetControl( IDC_ABSOLUTESTART ), BM_SETCHECK, ( WPARAM )BST_UNCHECKED, (LPARAM)0 );
|
|
}
|
|
else
|
|
{
|
|
SendMessage( GetControl( IDC_ABSOLUTESTART ), BM_SETCHECK, ( WPARAM )BST_CHECKED, (LPARAM)0 );
|
|
SendMessage( GetControl( IDC_RELATIVESTART ), BM_SETCHECK, ( WPARAM )BST_UNCHECKED, (LPARAM)0 );
|
|
}
|
|
}
|
|
|
|
void CBaseEventPropertiesDialog::GetSplineRect( HWND placeholder, RECT& rcOut )
|
|
{
|
|
GetWindowRect( placeholder, &rcOut );
|
|
RECT rcDlg;
|
|
GetWindowRect( m_hDialog, &rcDlg );
|
|
|
|
OffsetRect( &rcOut, -rcDlg.left, -rcDlg.top );
|
|
}
|
|
|
|
void CBaseEventPropertiesDialog::DrawSpline( HDC hdc, HWND placeholder, CChoreoEvent *e )
|
|
{
|
|
RECT rcOut;
|
|
|
|
GetSplineRect( placeholder, rcOut );
|
|
|
|
HBRUSH bg = CreateSolidBrush( GetSysColor( COLOR_BTNFACE ) );
|
|
FillRect( hdc, &rcOut, bg );
|
|
DeleteObject( bg );
|
|
|
|
if ( !e )
|
|
return;
|
|
|
|
// Draw spline
|
|
float range = ( float )( rcOut.right - rcOut.left );
|
|
if ( range <= 1.0f )
|
|
return;
|
|
|
|
float height = ( float )( rcOut.bottom - rcOut.top );
|
|
|
|
HPEN pen = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_BTNTEXT ) );
|
|
HPEN oldPen = (HPEN)SelectObject( hdc, pen );
|
|
|
|
float duration = e->GetDuration();
|
|
float starttime = e->GetStartTime();
|
|
|
|
for ( int i = 0; i < (int)range; i++ )
|
|
{
|
|
float frac = ( float )i / ( range - 1 );
|
|
|
|
float scale = 1.0f - e->GetIntensity( starttime + frac * duration );
|
|
|
|
int h = ( int ) ( scale * ( height - 1 ) );
|
|
|
|
if ( i == 0 )
|
|
{
|
|
MoveToEx( hdc, rcOut.left + i, rcOut.top + h, NULL );
|
|
}
|
|
else
|
|
{
|
|
LineTo( hdc, rcOut.left + i, rcOut.top + h );
|
|
}
|
|
}
|
|
|
|
SelectObject( hdc, oldPen );
|
|
|
|
HBRUSH frame = CreateSolidBrush( GetSysColor( COLOR_BTNSHADOW ) );
|
|
InflateRect( &rcOut, 1, 1 );
|
|
FrameRect( hdc, &rcOut, frame );
|
|
DeleteObject( frame );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *view -
|
|
// *actor -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int EventProperties( CEventParams *params )
|
|
{
|
|
int iret = 1;
|
|
switch ( params->m_nType )
|
|
{
|
|
default:
|
|
break;
|
|
case CChoreoEvent::EXPRESSION:
|
|
return EventProperties_Expression( params );
|
|
case CChoreoEvent::LOOKAT:
|
|
return EventProperties_LookAt( params );
|
|
case CChoreoEvent::MOVETO:
|
|
return EventProperties_MoveTo( params );
|
|
case CChoreoEvent::SPEAK:
|
|
return EventProperties_Speak( params );
|
|
case CChoreoEvent::GESTURE:
|
|
return EventProperties_Gesture( params );
|
|
case CChoreoEvent::SEQUENCE:
|
|
return EventProperties_Sequence( params );
|
|
case CChoreoEvent::FACE:
|
|
return EventProperties_Face( params );
|
|
case CChoreoEvent::FIRETRIGGER:
|
|
return EventProperties_FireTrigger( params );
|
|
case CChoreoEvent::FLEXANIMATION:
|
|
return EventProperties_FlexAnimation( params );
|
|
case CChoreoEvent::SUBSCENE:
|
|
return EventProperties_SubScene( params );
|
|
case CChoreoEvent::INTERRUPT:
|
|
return EventProperties_Interrupt( params );
|
|
case CChoreoEvent::PERMIT_RESPONSES:
|
|
return EventProperties_PermitResponses( params );
|
|
case CChoreoEvent::GENERIC:
|
|
return EventProperties_Generic( params );
|
|
}
|
|
|
|
return iret;
|
|
}
|