2894 lines
85 KiB
C++
2894 lines
85 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "tf_shareddefs.h"
|
|
#include "tf_playermodelpanel.h"
|
|
#include "tf_classdata.h"
|
|
#include "tf_item_inventory.h"
|
|
#include "vgui/IVGui.h"
|
|
#include "game_item_schema.h"
|
|
#include "econ_item_system.h"
|
|
#include "animation.h"
|
|
#include "choreoscene.h"
|
|
#include "choreoevent.h"
|
|
#include "choreoactor.h"
|
|
#include "choreochannel.h"
|
|
#include "scenefilecache/ISceneFileCache.h"
|
|
#include "c_sceneentity.h"
|
|
#include "c_baseflex.h"
|
|
#include "sentence.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "c_tf_player.h"
|
|
#include "tier2/renderutils.h"
|
|
#include "bone_setup.h"
|
|
#include "halloween/tf_weapon_spellbook.h"
|
|
#include "matsys_controls/matsyscontrols.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
DECLARE_BUILD_FACTORY( CTFPlayerModelPanel );
|
|
|
|
char g_szSceneTmpName[256];
|
|
|
|
static bool IsTauntItem( GameItemDefinition_t *pItemDef, const int iTeam, const int iClass, const char **ppSequence = NULL, const char **ppRequiredItem = NULL, const char **ppScene = NULL )
|
|
{
|
|
CTFTauntInfo *pTauntData = pItemDef->GetTauntData();
|
|
if ( pTauntData )
|
|
{
|
|
if ( ppScene )
|
|
{
|
|
int iTauntIndex = RandomInt( 0, pTauntData->GetIntroSceneCount( iClass ) - 1 );
|
|
*ppScene = pTauntData->GetIntroScene( iClass, iTauntIndex );
|
|
}
|
|
|
|
if ( ppRequiredItem )
|
|
{
|
|
*ppRequiredItem = pTauntData->GetProp( iClass );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
for ( int i=0; i<pItemDef->GetNumAnimations( iTeam ); ++i )
|
|
{
|
|
animation_on_wearable_t* pAnim = pItemDef->GetAnimationData( iTeam, i );
|
|
if ( pAnim && pAnim->pszActivity && !Q_stricmp( pAnim->pszActivity, "taunt_concept" ) )
|
|
{
|
|
// If we have a scene, use it first
|
|
const char *pszScene = pAnim->pszScene;
|
|
if ( pszScene && (iClass >= TF_FIRST_NORMAL_CLASS && iClass < TF_LAST_NORMAL_CLASS) )
|
|
{
|
|
if ( ppScene )
|
|
{
|
|
Q_snprintf( g_szSceneTmpName, sizeof(g_szSceneTmpName), "scenes/player/%s/low/%s", g_aPlayerClassNames_NonLocalized[iClass], pszScene );
|
|
*ppScene = g_szSceneTmpName;
|
|
}
|
|
}
|
|
|
|
const char *pszSequence = pAnim->pszSequence;
|
|
if ( pszSequence )
|
|
{
|
|
if ( ppSequence )
|
|
{
|
|
*ppSequence = pszSequence;
|
|
}
|
|
if ( ppRequiredItem )
|
|
{
|
|
*ppRequiredItem = pAnim->pszRequiredItem;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CTFPlayerModelPanel::CTFPlayerModelPanel( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName ),
|
|
m_LocalToGlobal( 0, 0, FlexSettingLessFunc )
|
|
{
|
|
m_iCurrentClassIndex = TF_CLASS_UNDEFINED;
|
|
m_iCurrentSlotIndex = -1;
|
|
|
|
m_nBody = 0;
|
|
m_pHeldItem = NULL;
|
|
m_iTeam = TF_TEAM_RED;
|
|
m_bZoomedToHead = false;
|
|
m_pszVCD = NULL;
|
|
m_pszWeaponEntityRequired = NULL;
|
|
m_bLoopVCD = true;
|
|
m_bVCDFileNameOnly = true;
|
|
|
|
InitPhonemeMappings();
|
|
|
|
m_pScene = NULL;
|
|
ClearScene();
|
|
memset( m_flexWeight, 0, sizeof( m_flexWeight ) );
|
|
|
|
SetIgnoreDoubleClick( true );
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( m_aParticleSystems ); i++ )
|
|
{
|
|
m_aParticleSystems[i] = NULL;
|
|
}
|
|
|
|
m_bPlaySparks = false;
|
|
m_pszEyeGlowParticleName[0] = '\0';
|
|
m_bDrawActionSlotEffects = false;
|
|
m_bDrawTauntParticles = false;
|
|
m_bIsRobot = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CTFPlayerModelPanel::~CTFPlayerModelPanel( void )
|
|
{
|
|
m_vecItemsLoaded.PurgeAndDeleteElements();
|
|
m_ItemsToCarry.PurgeAndDeleteElements();
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( m_aParticleSystems ); i++ )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[i] );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ApplySettings( KeyValues *inResourceData )
|
|
{
|
|
BaseClass::ApplySettings( inResourceData );
|
|
|
|
m_angPlayerOrg = m_angPlayer;
|
|
|
|
static ConVarRef cl_hud_minmode( "cl_hud_minmode", true );
|
|
if ( cl_hud_minmode.IsValid() && cl_hud_minmode.GetBool() )
|
|
{
|
|
inResourceData->ProcessResolutionKeys( "_minmode" );
|
|
}
|
|
|
|
// custom class data
|
|
m_customClassData.Purge();
|
|
KeyValues *pCustomData = inResourceData->FindKey( "customclassdata" );
|
|
if ( pCustomData )
|
|
{
|
|
for ( KeyValues *pData = pCustomData->GetFirstSubKey(); pData != NULL; pData = pData->GetNextKey() )
|
|
{
|
|
CustomClassData_t data;
|
|
data.m_flFOV = pData->GetFloat( "fov" );
|
|
data.m_vPosition.Init( pData->GetFloat( "origin_x" ), pData->GetFloat( "origin_y" ), pData->GetFloat( "origin_z" ) );
|
|
data.m_vAngles.Init( pData->GetFloat( "angles_x" ), pData->GetFloat( "angles_y" ), pData->GetFloat( "angles_z" ) );
|
|
m_customClassData.AddToTail( data );
|
|
}
|
|
|
|
Assert( m_customClassData.Count() == TF_LAST_NORMAL_CLASS );
|
|
}
|
|
|
|
// always allow particle for this panel
|
|
m_bUseParticle = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::SetToPlayerClass( int iClass, bool bIsRobot, bool bForceRefresh /*= false*/ )
|
|
{
|
|
if ( m_bIsRobot != bIsRobot )
|
|
{
|
|
bForceRefresh = true;
|
|
}
|
|
m_bIsRobot = bIsRobot;
|
|
|
|
if ( m_iCurrentClassIndex == iClass && !bForceRefresh )
|
|
return;
|
|
|
|
if ( m_bZoomedToHead )
|
|
{
|
|
ToggleZoom();
|
|
}
|
|
|
|
m_iCurrentClassIndex = iClass;
|
|
ClearScene();
|
|
|
|
if ( IsValidTFPlayerClass( m_iCurrentClassIndex ) )
|
|
{
|
|
if ( bIsRobot )
|
|
{
|
|
SetMDL( g_szPlayerRobotModels[ m_iCurrentClassIndex ] );
|
|
}
|
|
else
|
|
{
|
|
TFPlayerClassData_t *pData = GetPlayerClassData( m_iCurrentClassIndex );
|
|
SetMDL( pData->GetModelName() );
|
|
}
|
|
|
|
HoldFirstValidItem();
|
|
|
|
// set custom class data
|
|
if ( m_customClassData.IsValidIndex( m_iCurrentClassIndex ) )
|
|
{
|
|
SetCameraFOV( m_customClassData[m_iCurrentClassIndex].m_flFOV );
|
|
m_vecPlayerPos = m_customClassData[m_iCurrentClassIndex].m_vPosition;
|
|
m_angPlayer = m_customClassData[m_iCurrentClassIndex].m_vAngles;
|
|
}
|
|
else
|
|
{
|
|
m_angPlayer = m_angPlayerOrg;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetMDL( MDLHANDLE_INVALID );
|
|
RemoveAdditionalModels();
|
|
}
|
|
|
|
InitPhonemeMappings();
|
|
|
|
SetTeam( TF_TEAM_RED );
|
|
|
|
m_nBody = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::HoldFirstValidItem( void )
|
|
{
|
|
RemoveAdditionalModels();
|
|
|
|
if ( m_iCurrentClassIndex == TF_CLASS_UNDEFINED )
|
|
return;
|
|
|
|
int iDesiredSlot = -1;
|
|
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
bool bIsTauntItem = IsTauntItem( pItem->GetStaticData(), GetTeam(), m_iCurrentClassIndex );
|
|
if ( !bIsTauntItem )
|
|
{
|
|
if ( pItem->GetStaticData()->IsAWearable() )
|
|
continue;
|
|
if ( pItem->GetAnimationSlot() == -2 )
|
|
continue;
|
|
}
|
|
|
|
// Found a weapon. Wield it.
|
|
iDesiredSlot = pItem->GetStaticData()->GetLoadoutSlot( m_iCurrentClassIndex );
|
|
break;
|
|
}
|
|
|
|
if ( iDesiredSlot != -1 )
|
|
{
|
|
UpdateHeldItem( iDesiredSlot );
|
|
return;
|
|
}
|
|
|
|
// If we didn't find a weapon to wield, we wield the class's base primary weapon
|
|
CEconItemView *pItem = TFInventoryManager()->GetBaseItemForClass( m_iCurrentClassIndex, LOADOUT_POSITION_PRIMARY );
|
|
if ( !pItem || !pItem->IsValid() )
|
|
{
|
|
// Some classes only have secondary weapons. Fall back to that.
|
|
pItem = TFInventoryManager()->GetBaseItemForClass( m_iCurrentClassIndex, LOADOUT_POSITION_SECONDARY );
|
|
}
|
|
|
|
if ( pItem && pItem->IsValid() )
|
|
{
|
|
SwitchHeldItemTo( pItem );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::HoldItemInSlot( int iSlot )
|
|
{
|
|
if ( m_iCurrentClassIndex == TF_CLASS_UNDEFINED )
|
|
return false;
|
|
|
|
return UpdateHeldItem( iSlot );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::HoldItem( int iItemNumber )
|
|
{
|
|
if ( m_iCurrentClassIndex == TF_CLASS_UNDEFINED )
|
|
return false;
|
|
|
|
if ( iItemNumber >= m_ItemsToCarry.Count() )
|
|
return false;
|
|
|
|
CEconItemView *pItem = m_ItemsToCarry[iItemNumber];
|
|
|
|
bool bIsTauntitem = IsTauntItem( pItem->GetStaticData(), GetTeam(), m_iCurrentClassIndex );
|
|
|
|
// Ignore requests to equip wearables, because they're always equipped
|
|
// Also ignore requests to equip non-wearables that are never actively equipped
|
|
if ( bIsTauntitem || ( !pItem->GetStaticData()->IsAWearable() && pItem->GetAnimationSlot() != -2 ) )
|
|
{
|
|
SwitchHeldItemTo( pItem );
|
|
return true;
|
|
}
|
|
|
|
// If we were trying to switch to a new item, and it's not valid, stick to our current
|
|
if ( pItem->GetStaticData()->GetLoadoutSlot( m_iCurrentClassIndex ) != m_iCurrentSlotIndex )
|
|
{
|
|
UpdateHeldItem( m_iCurrentSlotIndex );
|
|
return false;
|
|
}
|
|
|
|
// We were trying to stay on the current weapon, and it's not valid. Find anything.
|
|
HoldFirstValidItem();
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::UpdateHeldItem( int iDesiredSlot )
|
|
{
|
|
m_pHeldItem = NULL;
|
|
|
|
CEconItemView *pItem = GetItemInSlot( iDesiredSlot );
|
|
if ( pItem )
|
|
{
|
|
bool bIsTauntItem = IsTauntItem( pItem->GetStaticData(), GetTeam(), m_iCurrentClassIndex );
|
|
// Ignore requests to equip wearables, because they're always equipped
|
|
// Also ignore requests to equip non-wearables that are never actively equipped
|
|
if ( bIsTauntItem || ( !pItem->GetStaticData()->IsAWearable() && pItem->GetAnimationSlot() != -2 ) )
|
|
{
|
|
SwitchHeldItemTo( pItem );
|
|
m_pHeldItem = pItem;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// If we were trying to switch to a new item, and it's not valid, stick to our current
|
|
if ( iDesiredSlot != m_iCurrentSlotIndex )
|
|
{
|
|
UpdateHeldItem( m_iCurrentSlotIndex );
|
|
return false;
|
|
}
|
|
|
|
// We were trying to stay on the current weapon, and it's not valid. Find anything.
|
|
HoldFirstValidItem();
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ClearScene( void )
|
|
{
|
|
if ( m_pScene )
|
|
{
|
|
delete m_pScene;
|
|
}
|
|
|
|
m_pScene = NULL;
|
|
m_flSceneTime = 0;
|
|
m_flSceneEndTime = 0;
|
|
m_flLastTickTime = 0;
|
|
m_bLoopScene = true;
|
|
//memset( m_flexWeight, 0, sizeof( m_flexWeight ) );
|
|
}
|
|
|
|
extern CChoreoStringPool g_ChoreoStringPool;
|
|
CChoreoScene *LoadSceneForModel( const char *filename, IChoreoEventCallback *pCallback, float *flSceneEndTime )
|
|
{
|
|
char loadfile[ 512 ];
|
|
V_strcpy_safe( loadfile, filename );
|
|
V_SetExtension( loadfile, ".vcd", sizeof( loadfile ) );
|
|
V_FixSlashes( loadfile );
|
|
|
|
char *pBuffer = NULL;
|
|
size_t bufsize = scenefilecache->GetSceneBufferSize( loadfile );
|
|
if ( bufsize <= 0 )
|
|
return NULL;
|
|
|
|
pBuffer = new char[ bufsize ];
|
|
if ( !scenefilecache->GetSceneData( filename, (byte *)pBuffer, bufsize ) )
|
|
{
|
|
delete[] pBuffer;
|
|
return NULL;
|
|
}
|
|
|
|
CChoreoScene *pScene;
|
|
if ( IsBufferBinaryVCD( pBuffer, bufsize ) )
|
|
{
|
|
pScene = new CChoreoScene( pCallback );
|
|
CUtlBuffer buf( pBuffer, bufsize, CUtlBuffer::READ_ONLY );
|
|
if ( !pScene->RestoreFromBinaryBuffer( buf, loadfile, &g_ChoreoStringPool ) )
|
|
{
|
|
Warning( "Unable to restore binary scene '%s'\n", loadfile );
|
|
delete pScene;
|
|
pScene = NULL;
|
|
}
|
|
else
|
|
{
|
|
pScene->SetPrintFunc( Scene_Printf );
|
|
pScene->SetEventCallbackInterface( pCallback );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_TokenProcessor.SetBuffer( pBuffer );
|
|
pScene = ChoreoLoadScene( loadfile, pCallback, &g_TokenProcessor, Scene_Printf );
|
|
}
|
|
|
|
delete[] pBuffer;
|
|
|
|
if ( flSceneEndTime != NULL )
|
|
{
|
|
// find the scene length
|
|
// The scene is as long as the end point for the last event unless one of the events is a loop
|
|
*flSceneEndTime = 0.0f;
|
|
bool bSetEndTime = false;
|
|
for ( int i = 0; i < pScene->GetNumEvents(); i++ )
|
|
{
|
|
CChoreoEvent *pEvent = pScene->GetEvent( i );
|
|
if ( pEvent->GetType() == CChoreoEvent::LOOP )
|
|
{
|
|
*flSceneEndTime = -1.0f;
|
|
bSetEndTime = false;
|
|
break;
|
|
}
|
|
|
|
if ( pEvent->GetEndTime() > *flSceneEndTime )
|
|
{
|
|
*flSceneEndTime = pEvent->GetEndTime();
|
|
bSetEndTime = true;
|
|
}
|
|
}
|
|
|
|
if ( bSetEndTime )
|
|
{
|
|
*flSceneEndTime += 0.1f; // give time for lerp to idle pose
|
|
}
|
|
}
|
|
|
|
return pScene;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::PlayVCD( const char *pszVCD, const char *pszWeaponEntityRequired /*= NULL*/, bool bLoopVCD /*= true*/, bool bFileNameOnly /*= true*/ )
|
|
{
|
|
m_pszVCD = pszVCD;
|
|
m_pszWeaponEntityRequired = pszWeaponEntityRequired;
|
|
m_bLoopVCD = bLoopVCD;
|
|
m_bVCDFileNameOnly = bFileNameOnly;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::FireEvent( const char *pszEventName, const char *pszEventOptions )
|
|
{
|
|
//Plat_DebugString( CFmtStr( "********* ANIM EVENT: %s\n", pszEventName ) );
|
|
|
|
if ( V_strcmp( pszEventName, "AE_WPN_HIDE" ) == 0 )
|
|
{
|
|
int nWeaponIndex = GetMergeMDLIndex( static_cast<IClientRenderable*>(m_pHeldItem) );
|
|
if ( nWeaponIndex >= 0 )
|
|
{
|
|
m_aMergeMDLs[nWeaponIndex].m_bDisabled = true;
|
|
}
|
|
}
|
|
else if ( V_strcmp( pszEventName, "AE_WPN_UNHIDE" ) == 0 )
|
|
{
|
|
int nWeaponIndex = GetMergeMDLIndex( static_cast<IClientRenderable*>(m_pHeldItem) );
|
|
if ( nWeaponIndex >= 0 )
|
|
{
|
|
m_aMergeMDLs[nWeaponIndex].m_bDisabled = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::SwitchHeldItemTo( CEconItemView *pItem )
|
|
{
|
|
m_nBody = 0;
|
|
|
|
ClearScene();
|
|
|
|
// Clear out visible items, and re-equip out wearables
|
|
RemoveAdditionalModels();
|
|
EquipAllWearables( pItem );
|
|
|
|
// Then equip the held item
|
|
EquipItem( pItem );
|
|
m_iCurrentSlotIndex = pItem->GetStaticData()->GetLoadoutSlot( m_iCurrentClassIndex );
|
|
m_pHeldItem = pItem;
|
|
|
|
m_StatTrackModel.m_bDisabled = true;
|
|
m_StatTrackModel.m_MDL.SetMDL( MDLHANDLE_INVALID );
|
|
CAttribute_String attrModule;
|
|
static CSchemaAttributeDefHandle pAttr_module( "weapon_uses_stattrak_module" );
|
|
if ( m_pHeldItem->FindAttribute( pAttr_module, &attrModule ) && attrModule.has_value() )
|
|
{
|
|
// Allow for already strange items
|
|
bool bIsStrange = false;
|
|
if ( m_pHeldItem->GetQuality() == AE_STRANGE )
|
|
{
|
|
bIsStrange = true;
|
|
}
|
|
|
|
if ( !bIsStrange )
|
|
{
|
|
// Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply
|
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
|
|
{
|
|
if ( m_pHeldItem->FindAttribute( GetKillEaterAttr_Score( i ) ) )
|
|
{
|
|
bIsStrange = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bIsStrange )
|
|
{
|
|
static CSchemaAttributeDefHandle pAttr_moduleScale( "weapon_stattrak_module_scale" );
|
|
// Does it have a stat track module
|
|
m_flStatTrackScale = 1.0f;
|
|
uint32 unFloatAsUint32 = 1;
|
|
if ( m_pHeldItem->FindAttribute( pAttr_moduleScale, &unFloatAsUint32 ) )
|
|
{
|
|
m_flStatTrackScale = (float&)unFloatAsUint32;
|
|
}
|
|
|
|
MDLHandle_t hStatTrackMDL = mdlcache->FindMDL( "models/weapons/c_models/stattrack.mdl" );
|
|
if ( mdlcache->IsErrorModel( hStatTrackMDL ) )
|
|
{
|
|
hStatTrackMDL = MDLHANDLE_INVALID;
|
|
}
|
|
m_StatTrackModel.m_MDL.SetMDL( hStatTrackMDL );
|
|
mdlcache->Release( hStatTrackMDL ); // counterbalance addref from within FindMDL
|
|
|
|
m_StatTrackModel.m_MDL.m_pProxyData = static_cast<IClientRenderable*>(pItem);
|
|
m_StatTrackModel.m_bDisabled = false;
|
|
m_StatTrackModel.m_MDL.m_nSequence = ACT_IDLE;
|
|
SetIdentityMatrix( m_StatTrackModel.m_MDLToWorld );
|
|
}
|
|
}
|
|
|
|
SetSequenceLayers( NULL, 0 );
|
|
|
|
// See if our VCD is overridden
|
|
if ( m_pszVCD )
|
|
{
|
|
// Make sure we're holding the weapon, if it's required
|
|
bool bCanRunScene = true;
|
|
if ( m_pszWeaponEntityRequired && *m_pszWeaponEntityRequired )
|
|
{
|
|
bCanRunScene = false;
|
|
|
|
if ( pItem && pItem->IsValid() )
|
|
{
|
|
const char *pszClassName = pItem->GetStaticData()->GetItemClass();
|
|
if ( pszClassName && *pszClassName )
|
|
{
|
|
bCanRunScene = V_stricmp( pszClassName, m_pszWeaponEntityRequired ) == 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bCanRunScene )
|
|
{
|
|
if ( m_bVCDFileNameOnly )
|
|
{
|
|
// auto complete relative path for the vcd file
|
|
V_sprintf_safe( g_szSceneTmpName, "scenes/player/%s/low/%s", g_aPlayerClassNames_NonLocalized[m_iCurrentClassIndex], m_pszVCD );
|
|
}
|
|
else
|
|
{
|
|
// m_pszVCD should be a valid relative path
|
|
V_strcpy_safe( g_szSceneTmpName, m_pszVCD );
|
|
}
|
|
|
|
m_pScene = LoadSceneForModel( g_szSceneTmpName, this, &m_flSceneEndTime );
|
|
m_bLoopScene = m_bLoopVCD;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
const char *pScene = NULL;
|
|
const char *pSequence = NULL;
|
|
const char *pRequiredItem = NULL;
|
|
bool bRemoveTauntParticles = true;
|
|
|
|
if ( IsTauntItem( pItem->GetStaticData(), GetTeam(), m_iCurrentClassIndex, &pSequence, &pRequiredItem, &pScene ) )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
|
|
if ( pScene )
|
|
{
|
|
m_pScene = LoadSceneForModel( pScene, this, &m_flSceneEndTime );
|
|
|
|
// load custom prop for taunt
|
|
const char *pszProp = pItem->GetStaticData()->GetTauntData()->GetProp( m_iCurrentClassIndex );
|
|
if ( pszProp )
|
|
{
|
|
LoadAndAttachAdditionalModel( pszProp, pItem );
|
|
}
|
|
|
|
// force taunt to equip certain slot
|
|
static CSchemaAttributeDefHandle pAttrDef_TauntForceWeaponSlot( "taunt force weapon slot" );
|
|
const char* pszTauntForceWeaponSlotName = NULL;
|
|
if ( FindAttribute_UnsafeBitwiseCast<CAttribute_String>( pItem, pAttrDef_TauntForceWeaponSlot, &pszTauntForceWeaponSlotName ) )
|
|
{
|
|
int iForceWeaponSlot = StringFieldToInt( pszTauntForceWeaponSlotName, GetItemSchema()->GetWeaponTypeSubstrings() );
|
|
EquipRequiredLoadoutSlot( iForceWeaponSlot );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ClearScene();
|
|
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
int iSequence = LookupSequence( &studioHdr, pSequence );
|
|
if ( iSequence >= 0 )
|
|
{
|
|
// does a weapon need to be equipped?
|
|
loadout_positions_t requiredLoadoutItem = LOADOUT_POSITION_INVALID;
|
|
if ( pRequiredItem )
|
|
{
|
|
requiredLoadoutItem = (loadout_positions_t)StringFieldToInt( pRequiredItem, ItemSystem()->GetItemSchema()->GetLoadoutStrings( pItem->GetItemDefinition()->GetEquipType() ) );
|
|
}
|
|
|
|
EquipRequiredLoadoutSlot( requiredLoadoutItem );
|
|
|
|
// finally, set the sequence layers
|
|
MDLSquenceLayer_t tmpSequenceLayers[1];
|
|
tmpSequenceLayers[0].m_nSequenceIndex = iSequence;
|
|
tmpSequenceLayers[0].m_flWeight = 1.0;
|
|
tmpSequenceLayers[0].m_bNoLoop = false;
|
|
tmpSequenceLayers[0].m_flCycleBeganAt = m_RootMDL.m_MDL.m_flTime;
|
|
SetSequenceLayers( tmpSequenceLayers, 1 );
|
|
}
|
|
}
|
|
|
|
// Taunt Particles
|
|
static CSchemaAttributeDefHandle pAttrDef_OnTauntAttachParticleIndex( "on taunt attach particle index" );
|
|
uint32 unUnusualEffectIndex = 0;
|
|
if ( pItem->FindAttribute( pAttrDef_OnTauntAttachParticleIndex, &unUnusualEffectIndex ) && unUnusualEffectIndex > 0 )
|
|
{
|
|
const attachedparticlesystem_t *pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( unUnusualEffectIndex );
|
|
if ( pParticleSystem )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[ SYSTEM_TAUNT ] );
|
|
m_aParticleSystems[ SYSTEM_TAUNT ] = CreateParticleData( pParticleSystem->pszSystemName );
|
|
m_flTauntParticleRefireTime = gpGlobals->curtime + pParticleSystem->fRefireTime;
|
|
m_flTauntParticleRefireRate = pParticleSystem->fRefireTime;
|
|
m_bDrawTauntParticles = true;
|
|
bRemoveTauntParticles = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear out taunt particles
|
|
if ( bRemoveTauntParticles && m_aParticleSystems[SYSTEM_TAUNT] )
|
|
{
|
|
m_bDrawTauntParticles = false;
|
|
SafeDeleteParticleData( &m_aParticleSystems[SYSTEM_TAUNT] );
|
|
}
|
|
|
|
// Check if it has a PoseParameter Attributes (r_hand_grip)
|
|
float flPose = 0;
|
|
static CSchemaAttributeDefHandle pAttrDef_RightHandPose( "righthand pose parameter" );
|
|
uint32 iValue = 0;
|
|
if ( pItem->FindAttribute( pAttrDef_RightHandPose, &iValue ) )
|
|
{
|
|
flPose = (float&)iValue;
|
|
}
|
|
SetPoseParameterByName( "r_hand_grip", flPose );
|
|
|
|
// Check for hand particles (spell book)
|
|
// always nuke
|
|
if ( m_aParticleSystems[ SYSTEM_ACTIONSLOT ] )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[ SYSTEM_ACTIONSLOT ] );
|
|
}
|
|
m_bDrawActionSlotEffects = false;
|
|
if ( pItem->GetStaticData()->GetItemClass() )
|
|
{
|
|
m_bDrawActionSlotEffects = FStrEq( pItem->GetStaticData()->GetItemClass(), "tf_weapon_spellbook" );
|
|
}
|
|
|
|
// update eyeglows
|
|
m_bUpdateEyeGlows = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::EquipRequiredLoadoutSlot( int iRequiredLoadoutSlot )
|
|
{
|
|
if ( iRequiredLoadoutSlot != LOADOUT_POSITION_INVALID )
|
|
{
|
|
int iDesiredSlot = -1;
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
if ( pItem->GetStaticData()->IsAWearable() )
|
|
continue;
|
|
if ( pItem->GetAnimationSlot() == -2 )
|
|
continue;
|
|
|
|
// Found a weapon. Wield it.
|
|
if ( iRequiredLoadoutSlot == pItem->GetStaticData()->GetLoadoutSlot( m_iCurrentClassIndex ) )
|
|
{
|
|
iDesiredSlot = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( iDesiredSlot >= 0 )
|
|
{
|
|
EquipItem( m_ItemsToCarry[iDesiredSlot] );
|
|
}
|
|
else
|
|
{
|
|
// If we didn't find a weapon in the appropriate slot, get the base item
|
|
CEconItemView *pWeapon = TFInventoryManager()->GetBaseItemForClass( m_iCurrentClassIndex, iRequiredLoadoutSlot );
|
|
if ( pWeapon && pWeapon->IsValid() )
|
|
{
|
|
EquipItem( pWeapon );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::UpdateWeaponBodygroups( bool bModifyDeployedOnlyBodygroups )
|
|
{
|
|
for ( int i=0; i<MAX_WEAPON_SLOTS; i++ )
|
|
{
|
|
CEconItemView *pItem = GetItemInSlot( i );
|
|
if ( !pItem )
|
|
continue;
|
|
|
|
if ( pItem->GetStaticData()->GetHideBodyGroupsDeployedOnly() != bModifyDeployedOnlyBodygroups )
|
|
continue;
|
|
|
|
if ( !(m_pHeldItem == pItem || !pItem->GetStaticData()->GetHideBodyGroupsDeployedOnly()) )
|
|
continue;
|
|
|
|
UpdateHiddenBodyGroups( pItem );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::UpdateHiddenBodyGroups( CEconItemView* pItem )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
int iNumBodyGroups = pItem->GetStaticData()->GetNumModifiedBodyGroups( 0 );
|
|
for ( int i=0; i<iNumBodyGroups; ++i )
|
|
{
|
|
int iState = 0;
|
|
const char *pszBodyGroup = pItem->GetStaticData()->GetModifiedBodyGroup( 0, i, iState );
|
|
int iBodyGroup = FindBodygroupByName( &studioHdr, pszBodyGroup );
|
|
|
|
if ( iBodyGroup == -1 )
|
|
continue;
|
|
|
|
::SetBodygroup( &studioHdr, m_nBody, iBodyGroup, iState );
|
|
SetBody( m_nBody );
|
|
}
|
|
|
|
// Handle style-based bodygroups
|
|
const CEconItemDefinition *pItemDef = pItem->GetItemDefinition();
|
|
const CEconStyleInfo *pStyle = pItemDef ? pItemDef->GetStyleInfo( pItem->GetStyle() ) : NULL;
|
|
if ( pStyle )
|
|
{
|
|
FOR_EACH_VEC( pStyle->GetAdditionalHideBodygroups(), i )
|
|
{
|
|
int iBodyGroup = FindBodygroupByName( &studioHdr, pStyle->GetAdditionalHideBodygroups()[i] );
|
|
|
|
if ( iBodyGroup == -1 )
|
|
continue;
|
|
|
|
::SetBodygroup( &studioHdr, m_nBody, iBodyGroup, 1 ); // force state to '1' here to mean hidden
|
|
SetBody( m_nBody );
|
|
}
|
|
}
|
|
|
|
// Handle world model bodygroup overrides
|
|
int iBodyOverride = pItem->GetStaticData()->GetWorldmodelBodygroupOverride( m_iTeam );
|
|
int iBodyStateOverride = pItem->GetStaticData()->GetWorldmodelBodygroupStateOverride( m_iTeam );
|
|
if ( iBodyOverride > -1 && iBodyStateOverride > -1 )
|
|
{
|
|
::SetBodygroup( &studioHdr, m_nBody, iBodyOverride, iBodyStateOverride );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemView *CTFPlayerModelPanel::GetItemInSlot( int iSlot )
|
|
{
|
|
CEconItemView *pOwnedItemInSlot = TFInventoryManager()->GetItemInLoadoutForClass( m_iCurrentClassIndex, iSlot );
|
|
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
int iLoadoutSlot = pItem->GetStaticData()->GetLoadoutSlot( m_iCurrentClassIndex );
|
|
if ( iSlot == iLoadoutSlot )
|
|
return pItem;
|
|
|
|
// GetLoadoutSlot will not work for misc2, taunt2-8 because it will always return misc/taunt
|
|
if ( pOwnedItemInSlot && pOwnedItemInSlot->GetItemDefIndex() == pItem->GetItemDefIndex() )
|
|
return pItem;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::EquipAllWearables( CEconItemView *pHeldItem )
|
|
{
|
|
// First, reset all our bodygroups
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
const CEconItemSchema::BodygroupStateMap_t& mapBodygroupState = GetItemSchema()->GetDefaultBodygroupStateMap();
|
|
|
|
FOR_EACH_MAP_FAST( mapBodygroupState, i )
|
|
{
|
|
const char *pszBodygroupName = mapBodygroupState.Key(i);
|
|
int iBodyGroup = FindBodygroupByName( &studioHdr, pszBodygroupName );
|
|
if ( iBodyGroup > -1 )
|
|
{
|
|
int iState = mapBodygroupState[i];
|
|
::SetBodygroup( &studioHdr, m_nBody, iBodyGroup, iState );
|
|
}
|
|
}
|
|
|
|
SetBody( m_nBody );
|
|
|
|
UpdateWeaponBodygroups( false );
|
|
|
|
// Now equip each of our wearables
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
// If it's a wearable item, we put it on.
|
|
if ( pItem->GetStaticData()->IsAWearable() )
|
|
{
|
|
EquipItem( pItem );
|
|
}
|
|
|
|
// Then see if there's an extra wearable we need to attach for this item
|
|
const char *pszAttached = pItem->GetExtraWearableModel();
|
|
if ( pszAttached && pszAttached[ 0 ] )
|
|
{
|
|
const char *pszViewModelAttached = pItem->GetExtraWearableViewModel();
|
|
if ( pHeldItem == pItem || pszViewModelAttached == NULL || pszViewModelAttached[ 0 ] == '\0' || pszViewModelAttached[ 0 ] == '?' )
|
|
{
|
|
LoadAndAttachAdditionalModel( pszAttached, pItem );
|
|
}
|
|
}
|
|
}
|
|
|
|
UpdateWeaponBodygroups( true );
|
|
|
|
SetBody( m_nBody );
|
|
|
|
UpdatePreviewVisuals();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::EquipItem( CEconItemView *pItem )
|
|
{
|
|
if ( m_iCurrentClassIndex == TF_CLASS_UNDEFINED )
|
|
return;
|
|
|
|
const GameItemDefinition_t *pItemDef = pItem->GetItemDefinition();
|
|
Assert( pItemDef );
|
|
|
|
// Change team number so skins composite correctly
|
|
pItem->SetTeamNumber( m_iTeam );
|
|
|
|
// Non wearables can modify the animation
|
|
if ( !pItemDef->IsAWearable() )
|
|
{
|
|
int iAnimSlot = pItem->GetAnimationSlot();
|
|
|
|
// Ignore items that don't want to control player animation
|
|
if ( iAnimSlot == -2 )
|
|
return;
|
|
|
|
if ( iAnimSlot == -1 )
|
|
{
|
|
iAnimSlot = pItemDef->GetLoadoutSlot( m_iCurrentClassIndex );
|
|
}
|
|
|
|
const CUtlVector<const char *>& vecWeaponTypeSubstrings = GetItemSchema()->GetWeaponTypeSubstrings();
|
|
if ( vecWeaponTypeSubstrings.IsValidIndex( iAnimSlot ) )
|
|
{
|
|
int iAnim = FindAnimByName( vecWeaponTypeSubstrings[iAnimSlot] );
|
|
SetModelAnim( iAnim );
|
|
}
|
|
}
|
|
|
|
// Attach the models for the item
|
|
const char *pszAttached = pItem->GetWorldDisplayModel();
|
|
if ( !pszAttached )
|
|
{
|
|
pszAttached = pItem->GetPlayerDisplayModel( m_iCurrentClassIndex, m_iTeam );
|
|
}
|
|
|
|
if ( pszAttached && pszAttached[0] )
|
|
{
|
|
LoadAndAttachAdditionalModel( pszAttached, pItem );
|
|
|
|
int iTeam = pItemDef->GetBestVisualTeamData( m_iTeam );
|
|
// Set attached models if viewable third-person.
|
|
{
|
|
const int iNumAttachedModels = pItemDef->GetNumAttachedModels( iTeam );
|
|
for ( int i = 0; i < iNumAttachedModels; ++i )
|
|
{
|
|
attachedmodel_t *pModel = pItemDef->GetAttachedModelData( iTeam, i );
|
|
|
|
if ( !( pModel->m_iModelDisplayFlags & kAttachedModelDisplayFlag_WorldModel ) )
|
|
continue;
|
|
|
|
if ( !pModel->m_pszModelName )
|
|
{
|
|
Warning( "econ item definition '%s' attachment (team %d idx %d) has no model\n", pItemDef->GetDefinitionName(), iTeam, i );
|
|
continue;
|
|
}
|
|
|
|
LoadAndAttachAdditionalModel( pModel->m_pszModelName, pItem );
|
|
}
|
|
}
|
|
|
|
// Festive
|
|
// Set attached models if viewable third-person.
|
|
static CSchemaAttributeDefHandle pAttr_is_festivized( "is_festivized" );
|
|
if ( pAttr_is_festivized && pItem->FindAttribute( pAttr_is_festivized ) )
|
|
{
|
|
const int iNumAttachedModels = pItemDef->GetNumAttachedModelsFestivized( iTeam );
|
|
for ( int i = 0; i < iNumAttachedModels; ++i )
|
|
{
|
|
attachedmodel_t *pModel = pItemDef->GetAttachedModelDataFestivized( iTeam, i );
|
|
|
|
if ( !( pModel->m_iModelDisplayFlags & kAttachedModelDisplayFlag_WorldModel ) )
|
|
continue;
|
|
|
|
if ( !pModel->m_pszModelName )
|
|
{
|
|
Warning( "econ item definition '%s' attachment (team %d idx %d) has no model\n", pItemDef->GetDefinitionName(), iTeam, i );
|
|
continue;
|
|
}
|
|
|
|
LoadAndAttachAdditionalModel( pModel->m_pszModelName, pItem );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Hide any item associated groups.
|
|
UpdateHiddenBodyGroups( pItem );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CTFPlayerModelPanel::AddCarriedItem( CEconItemView *pItem )
|
|
{
|
|
CEconItemView *pNewItem = new CEconItemView;
|
|
*pNewItem = *pItem;
|
|
int iIdx = m_ItemsToCarry.AddToTail( pNewItem );
|
|
|
|
// This is a terrible hack. If we have team paint, we need an entity to find out what team
|
|
// we're on, but in this panel we don't have one. Instead, we force a flag all the way through
|
|
// the system on the CEconItemView so that the low-level paint code can pull from it if necessary.
|
|
if ( GetTeam() == TF_TEAM_BLUE )
|
|
{
|
|
pNewItem->SetClientItemFlags( kEconItemFlagClient_ForceBlueTeam );
|
|
}
|
|
|
|
return iIdx;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ClearCarriedItems( void )
|
|
{
|
|
RemoveAdditionalModels();
|
|
m_ItemsToCarry.PurgeAndDeleteElements();
|
|
m_pHeldItem = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::RemoveAdditionalModels( void )
|
|
{
|
|
ClearMergeMDLs();
|
|
|
|
// Unregister for all callbacks
|
|
modelinfo->UnregisterModelLoadCallback( -1, this );
|
|
m_vecDynamicAssetsLoaded.Purge();
|
|
m_vecItemsLoaded.PurgeAndDeleteElements();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::LoadAndAttachAdditionalModel( const char *pMDLName, CEconItemView *pItem )
|
|
{
|
|
int nModelIndex = -1;
|
|
|
|
if ( pItem->GetStaticData()->IsContentStreamable() )
|
|
{
|
|
// Get the client-only dynamic model index. The auto-addref
|
|
// of vecDynamicAssetsLoaded will actually trigger the load.
|
|
nModelIndex = modelinfo->RegisterDynamicModel( pMDLName, true );
|
|
// Dynamic models never fail to register in this engine.
|
|
Assert( nModelIndex != -1 );
|
|
}
|
|
else
|
|
{
|
|
// Is the (non-streamable) model already precached? If so, use it.
|
|
nModelIndex = modelinfo->GetModelIndex( pMDLName );
|
|
}
|
|
|
|
if ( nModelIndex == -1 )
|
|
{
|
|
MDLHandle_t hMDL = vgui::MDLCache()->FindMDL( pMDLName );
|
|
Assert( hMDL != MDLHANDLE_INVALID );
|
|
if ( hMDL != MDLHANDLE_INVALID )
|
|
{
|
|
// Model not loaded, not dynamic. Hard load and exit out.
|
|
SetMergeMDL( hMDL, static_cast<IClientRenderable*>(pItem), pItem->GetSkin( m_iTeam ) );
|
|
}
|
|
m_MergeMDL = hMDL;
|
|
return;
|
|
}
|
|
|
|
CEconItemView *pClone = new CEconItemView;
|
|
*pClone = *pItem;
|
|
m_vecDynamicAssetsLoaded[ m_vecDynamicAssetsLoaded.AddToTail() ] = nModelIndex;
|
|
m_vecItemsLoaded.AddToTail( pClone );
|
|
|
|
// callback triggers immediately if not dynamic
|
|
modelinfo->RegisterModelLoadCallback( nModelIndex, this, true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static void SetMDLSkinForTeam( CMDL *pMDL, const CEconItemView *pItem, int iTeam )
|
|
{
|
|
Assert( pItem );
|
|
|
|
if ( !pMDL )
|
|
return;
|
|
|
|
// Ask the item for a skin...
|
|
int nSkin = pItem->GetSkin( iTeam );
|
|
|
|
if ( nSkin == -1 )
|
|
{
|
|
// ... if not, use the team skin.
|
|
nSkin = iTeam == TF_TEAM_RED ? 0 : 1;
|
|
}
|
|
|
|
pMDL->m_nSkin = nSkin;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::OnModelLoadComplete( const model_t *pModel )
|
|
{
|
|
CEconItemView *pItem = NULL;
|
|
FOR_EACH_VEC_BACK( m_vecDynamicAssetsLoaded, i )
|
|
{
|
|
if ( modelinfo->GetModel( m_vecDynamicAssetsLoaded[ i ] ) == pModel )
|
|
{
|
|
pItem = GetPreviewItem( m_vecItemsLoaded[ i ] );
|
|
break;
|
|
}
|
|
}
|
|
|
|
Assert( pItem );
|
|
if ( pItem )
|
|
{
|
|
MDLHandle_t hMDL = modelinfo->GetCacheHandle( pModel );
|
|
Assert( hMDL != MDLHANDLE_INVALID );
|
|
if ( hMDL != MDLHANDLE_INVALID )
|
|
{
|
|
SetMergeMDL( hMDL, static_cast<IClientRenderable*>(pItem) );
|
|
|
|
int nBody = 0;
|
|
if ( pItem->GetStaticData()->UsesPerClassBodygroups( m_iTeam ) )
|
|
{
|
|
CMDL *pMDL = GetMergeMDL(hMDL);
|
|
if ( pMDL )
|
|
{
|
|
// Classes start at 1, bodygroups at 0, so we shift them all back 1.
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
CStudioHdr sHDR( pMDL->GetStudioHdr(), g_pMDLCache );
|
|
::SetBodygroup( &sHDR, nBody, 1, m_iCurrentClassIndex-1 );
|
|
pMDL->m_nBody = nBody;
|
|
}
|
|
}
|
|
|
|
// Set the custom skin.
|
|
SetMDLSkinForTeam( GetMergeMDL( hMDL ), pItem, m_iTeam );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTFPlayerModelPanel::SetTeam( int iTeam )
|
|
{
|
|
m_iTeam = iTeam;
|
|
|
|
UpdatePreviewVisuals();
|
|
}
|
|
|
|
void CTFPlayerModelPanel::UpdatePreviewVisuals()
|
|
{
|
|
// Assume skin will be chosen based only on the preview team
|
|
int iSkin = m_iTeam == TF_TEAM_RED ? 0 : 1;
|
|
|
|
// Check if any of the items we're carrying should override this
|
|
static CSchemaAttributeDefHandle pAttrDef_PlayerSkinOverride( "player skin override" );
|
|
Assert( pAttrDef_PlayerSkinOverride );
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
if ( !pItem )
|
|
continue;
|
|
float fSkinOverride = 0.0f;
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrDef_PlayerSkinOverride, &fSkinOverride ) && fSkinOverride == 1.0f )
|
|
{
|
|
C_TFPlayer::AdjustSkinIndexForZombie( m_iCurrentClassIndex, iSkin );
|
|
break;
|
|
}
|
|
Assert( fSkinOverride == 0.0f );
|
|
}
|
|
|
|
// Set the player model skin.
|
|
SetSkin( iSkin );
|
|
|
|
// Set the weapon's skin.
|
|
if ( m_MergeMDL && m_pHeldItem )
|
|
{
|
|
SetMDLSkinForTeam( GetMergeMDL( m_MergeMDL ), GetPreviewItem( m_pHeldItem ), m_iTeam );
|
|
}
|
|
|
|
// Set the skin for all other equipped items (wearables, etc).
|
|
for ( int i=0; i<m_vecDynamicAssetsLoaded.Count(); i++ )
|
|
{
|
|
const model_t *pModel = modelinfo->GetModel( m_vecDynamicAssetsLoaded[i] );
|
|
if ( pModel )
|
|
{
|
|
MDLHandle_t hMDL = modelinfo->GetCacheHandle( pModel );
|
|
|
|
// We're iterating over a list of the dynamic assets that we've completed streaming in, but
|
|
// we want to set the style based on the "preview item" definition if possible.
|
|
SetMDLSkinForTeam( GetMergeMDL( hMDL ), GetPreviewItem( m_vecItemsLoaded[i] ), m_iTeam );
|
|
}
|
|
}
|
|
}
|
|
|
|
CEconItemView *CTFPlayerModelPanel::GetPreviewItem( CEconItemView *pMatchItem )
|
|
{
|
|
Assert( pMatchItem );
|
|
if ( !pMatchItem )
|
|
return NULL;
|
|
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
if ( *pMatchItem == *pItem )
|
|
return pItem;
|
|
}
|
|
|
|
return pMatchItem;
|
|
}
|
|
|
|
int ClassZoomZ[] =
|
|
{
|
|
0,
|
|
20, // TF_CLASS_SCOUT,
|
|
25, // TF_CLASS_SNIPER,
|
|
20, // TF_CLASS_SOLDIER,
|
|
22, // TF_CLASS_DEMOMAN,
|
|
30, // TF_CLASS_MEDIC,
|
|
30, // TF_CLASS_HEAVYWEAPONS,
|
|
22, // TF_CLASS_PYRO,
|
|
27, // TF_CLASS_SPY,
|
|
20, // TF_CLASS_ENGINEER,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ToggleZoom()
|
|
{
|
|
m_bZoomedToHead = !m_bZoomedToHead;
|
|
|
|
// NOTE: GetZoomOffset() relies on m_bZoomedToHead being up to date
|
|
m_vecPlayerPos += GetZoomOffset();
|
|
|
|
SetModelAnglesAndPosition( m_angPlayer, m_vecPlayerPos );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
Vector CTFPlayerModelPanel::GetZoomOffset()
|
|
{
|
|
const Vector vecOffset( 100, 0, ClassZoomZ[m_iCurrentClassIndex] );
|
|
return m_bZoomedToHead ? -vecOffset : vecOffset;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::PrePaint3D( IMatRenderContext *pRenderContext )
|
|
{
|
|
if ( g_PlayerPreviewEffect.GetEffect() == C_TFPlayerPreviewEffect::PREVIEW_EFFECT_UBER )
|
|
{
|
|
modelrender->ForcedMaterialOverride( *g_PlayerPreviewEffect.GetInvulnMaterialRef() );
|
|
}
|
|
|
|
BaseClass::PrePaint3D( pRenderContext );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::PostPaint3D( IMatRenderContext *pRenderContext )
|
|
{
|
|
if ( g_PlayerPreviewEffect.GetEffect() == C_TFPlayerPreviewEffect::PREVIEW_EFFECT_UBER )
|
|
{
|
|
modelrender->ForcedMaterialOverride( NULL );
|
|
}
|
|
|
|
static bool bAlternate = false;
|
|
Vector vColor = bAlternate ? m_vEyeGlowColor1 : m_vEyeGlowColor2;
|
|
bAlternate = !bAlternate;
|
|
// Eye glows
|
|
if ( m_aParticleSystems[ SYSTEM_EYEGLOW_RIGHT ] )
|
|
{
|
|
m_aParticleSystems[ SYSTEM_EYEGLOW_RIGHT ]->m_pParticleSystem->SetControlPoint( CUSTOM_COLOR_CP1, vColor );
|
|
}
|
|
if ( m_aParticleSystems[ SYSTEM_EYESPARK_RIGHT ] )
|
|
{
|
|
m_aParticleSystems[ SYSTEM_EYESPARK_RIGHT ]->m_pParticleSystem->SetControlPoint( CUSTOM_COLOR_CP1, vColor );
|
|
}
|
|
|
|
if ( m_aParticleSystems[ SYSTEM_EYEGLOW_LEFT ] )
|
|
{
|
|
m_aParticleSystems[ SYSTEM_EYEGLOW_LEFT ]->m_pParticleSystem->SetControlPoint( CUSTOM_COLOR_CP1, vColor );
|
|
}
|
|
if ( m_aParticleSystems[ SYSTEM_EYESPARK_LEFT ])
|
|
{
|
|
m_aParticleSystems[ SYSTEM_EYESPARK_LEFT ]->m_pParticleSystem->SetControlPoint( CUSTOM_COLOR_CP1, vColor );
|
|
}
|
|
|
|
m_bUpdateEyeGlows = false;
|
|
m_bPlaySparks = false;
|
|
|
|
// remove all particles that are not up-to-date before simulating the updated ones in the base
|
|
for ( int i = 0; i < ARRAYSIZE( m_aParticleSystems ); i++ )
|
|
{
|
|
if ( m_aParticleSystems[i] && !m_aParticleSystems[i]->m_bIsUpdateToDate )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[i] );
|
|
}
|
|
}
|
|
|
|
BaseClass::PostPaint3D( pRenderContext );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose : Called by base Mdlpanel when a merged mdl has been drawn
|
|
// For TF we use this as a way to render effects on top of model as appropriate (ie Unusual effects)
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::RenderingRootModel( IMatRenderContext *pRenderContext, CStudioHdr *pStudioHdr, MDLHandle_t mdlHandle, matrix3x4_t *pWorldMatrix )
|
|
{
|
|
if ( !m_bUseParticle )
|
|
return;
|
|
|
|
// Eye Glows
|
|
UpdateEyeGlows( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix, true );
|
|
UpdateEyeGlows( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix, false );
|
|
|
|
// Right hand
|
|
UpdateActionSlotEffects( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix );
|
|
|
|
// Taunt Effects
|
|
UpdateTauntEffects( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix );
|
|
}
|
|
|
|
CEconItemView *CTFPlayerModelPanel::GetLoadoutItemFromMDLHandle( loadout_positions_t iPosition, MDLHandle_t mdlHandle )
|
|
{
|
|
// Check if we have a particle hat, if not ignore
|
|
CEconItemView *pEconItem = NULL;
|
|
|
|
// Find this item
|
|
FOR_EACH_VEC( m_ItemsToCarry, i )
|
|
{
|
|
CEconItemView *pItem = m_ItemsToCarry[i];
|
|
int iLoadoutSlot = pItem->GetStaticData()->GetLoadoutSlot( m_iCurrentClassIndex );
|
|
if ( ( IsMiscSlot( iLoadoutSlot ) && IsMiscSlot( iPosition ) ) ||
|
|
( IsValidPickupWeaponSlot( iLoadoutSlot ) && iLoadoutSlot == iPosition ) )
|
|
{
|
|
const char * pDisplayModel = pItem->GetPlayerDisplayModel( m_iCurrentClassIndex, m_iTeam );
|
|
if ( pDisplayModel )
|
|
{
|
|
MDLHandle_t hMDLFindResult = vgui::MDLCache()->FindMDL( pDisplayModel );
|
|
// compare the model to make sure that this is the same item
|
|
if ( hMDLFindResult == mdlHandle )
|
|
{
|
|
pEconItem = pItem;
|
|
vgui::MDLCache()->Release(hMDLFindResult); // counterbalance addref from within FindMDL
|
|
break;
|
|
}
|
|
vgui::MDLCache()->Release(hMDLFindResult);
|
|
}
|
|
}
|
|
}
|
|
|
|
return pEconItem;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::RenderingMergedModel( IMatRenderContext *pRenderContext, CStudioHdr *pStudioHdr, MDLHandle_t mdlHandle, matrix3x4_t *pWorldMatrix )
|
|
{
|
|
if ( !m_bUseParticle )
|
|
return;
|
|
|
|
static struct MergeModelSlot_t
|
|
{
|
|
loadout_positions_t iPosition;
|
|
modelpanel_particle_system_t iSystem;
|
|
} s_mergeModelSlot[] =
|
|
{
|
|
{ LOADOUT_POSITION_HEAD, SYSTEM_HEAD },
|
|
{ LOADOUT_POSITION_MISC, SYSTEM_MISC1 },
|
|
{ LOADOUT_POSITION_MISC2, SYSTEM_MISC2 },
|
|
{ LOADOUT_POSITION_PRIMARY, SYSTEM_WEAPON },
|
|
{ LOADOUT_POSITION_SECONDARY, SYSTEM_WEAPON },
|
|
{ LOADOUT_POSITION_MELEE, SYSTEM_WEAPON },
|
|
};
|
|
|
|
modelpanel_particle_system_t iSystem = SYSTEM_HEAD;
|
|
loadout_positions_t iPosition = LOADOUT_POSITION_INVALID;
|
|
CEconItemView *pEconItem = NULL;
|
|
int count = ARRAYSIZE( s_mergeModelSlot );
|
|
for ( int i=0; i<count; ++i )
|
|
{
|
|
// find the item for this model
|
|
pEconItem = GetLoadoutItemFromMDLHandle( s_mergeModelSlot[i].iPosition, mdlHandle );
|
|
if ( pEconItem )
|
|
{
|
|
iPosition = s_mergeModelSlot[i].iPosition;
|
|
iSystem = s_mergeModelSlot[i].iSystem;
|
|
|
|
// this is horrible but this fixes multiple unusual cosmetics with same default loadout to update their particles
|
|
if ( m_aParticleSystems[ iSystem ] && m_aParticleSystems[ iSystem ]->m_bIsUpdateToDate )
|
|
continue;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// couldn't find matching item for this model, do nothing
|
|
if ( !pEconItem )
|
|
return;
|
|
|
|
// Unusual Particles
|
|
// Update Misc Particles 1 by 1, Unfortunately the equip location is generic (MISC_SLOT) and not the specific slot
|
|
// so we have to test each slot individually
|
|
UpdateCosmeticParticles( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix, iSystem, pEconItem );
|
|
|
|
if ( m_iCurrentSlotIndex == iPosition )
|
|
{
|
|
RenderStatTrack( pStudioHdr, pWorldMatrix );
|
|
}
|
|
}
|
|
|
|
IMaterial* CTFPlayerModelPanel::GetOverrideMaterial( MDLHandle_t mdlHandle )
|
|
{
|
|
loadout_positions_t s_iPosition[] = {
|
|
LOADOUT_POSITION_HEAD,
|
|
LOADOUT_POSITION_MISC,
|
|
LOADOUT_POSITION_MISC2,
|
|
LOADOUT_POSITION_PRIMARY,
|
|
LOADOUT_POSITION_SECONDARY,
|
|
LOADOUT_POSITION_MELEE
|
|
};
|
|
|
|
int count = ARRAYSIZE( s_iPosition );
|
|
for ( int i = 0; i < count; ++i )
|
|
{
|
|
CEconItemView *pEconItem = GetLoadoutItemFromMDLHandle( s_iPosition[ i ], mdlHandle );
|
|
if ( pEconItem )
|
|
return pEconItem->GetMaterialOverride( m_iTeam );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::RenderStatTrack( CStudioHdr *pStudioHdr, matrix3x4_t *pWorldMatrix )
|
|
{
|
|
// Draw the merge MDLs.
|
|
if ( !m_StatTrackModel.m_bDisabled )
|
|
{
|
|
matrix3x4_t matMergeBoneToWorld[MAXSTUDIOBONES];
|
|
|
|
// Get the merge studio header.
|
|
studiohdr_t *pStatTrackStudioHdr = m_StatTrackModel.m_MDL.GetStudioHdr();
|
|
matrix3x4_t *pMergeBoneToWorld = &matMergeBoneToWorld[0];
|
|
|
|
// If we have a valid mesh, bonemerge it. If we have an invalid mesh we can't bonemerge because
|
|
// it'll crash trying to pull data from the missing header.
|
|
if ( pStatTrackStudioHdr != NULL )
|
|
{
|
|
CStudioHdr mergeHdr( pStatTrackStudioHdr, g_pMDLCache );
|
|
m_StatTrackModel.m_MDL.SetupBonesWithBoneMerge( &mergeHdr, pMergeBoneToWorld, pStudioHdr, pWorldMatrix, m_StatTrackModel.m_MDLToWorld );
|
|
for ( int i=0; i<mergeHdr.numbones(); ++i )
|
|
{
|
|
MatrixScaleBy( m_flStatTrackScale, pMergeBoneToWorld[i] );
|
|
}
|
|
m_StatTrackModel.m_MDL.Draw( m_StatTrackModel.m_MDLToWorld, pMergeBoneToWorld );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::UpdateCosmeticParticles(
|
|
IMatRenderContext *pRenderContext,
|
|
CStudioHdr *pStudioHdr,
|
|
MDLHandle_t mdlHandle,
|
|
matrix3x4_t *pWorldMatrix,
|
|
modelpanel_particle_system_t iSystem,
|
|
CEconItemView *pEconItem
|
|
)
|
|
{
|
|
if ( m_aParticleSystems[ iSystem ] && m_aParticleSystems[ iSystem ]->m_bIsUpdateToDate )
|
|
return false;
|
|
|
|
attachedparticlesystem_t *pParticleSystem = NULL;
|
|
|
|
// do community_sparkle effect if this is a community item?
|
|
const int iQualityParticleType = pEconItem->GetQualityParticleType();
|
|
if ( iQualityParticleType > 0 )
|
|
{
|
|
pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iQualityParticleType );
|
|
}
|
|
|
|
if ( !pParticleSystem )
|
|
{
|
|
// does this hat even have a particle effect
|
|
static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" );
|
|
uint32 iValue = 0;
|
|
if ( !pEconItem->FindAttribute( pAttrDef_AttachParticleEffect, &iValue ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const float& value_as_float = (float&)iValue;
|
|
pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( value_as_float );
|
|
}
|
|
|
|
// failed to find any particle effect
|
|
if ( !pParticleSystem )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Team Color
|
|
if ( GetTeam() == TF_TEAM_BLUE && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_red" ))
|
|
{
|
|
static char pBlue[256];
|
|
V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 );
|
|
pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pBlue );
|
|
if ( !pParticleSystem )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// if this thing has a bip_head or prp_helmet (aka a hat)
|
|
int iBone = Studio_BoneIndexByName( pStudioHdr, "bip_head" );
|
|
if ( iBone < 0 )
|
|
{
|
|
iBone = Studio_BoneIndexByName( pStudioHdr, "prp_helmet" );
|
|
if ( iBone < 0 )
|
|
{
|
|
iBone = Studio_BoneIndexByName( pStudioHdr, "prp_hat" );
|
|
}
|
|
}
|
|
|
|
// default to root
|
|
if ( iBone < 0 )
|
|
{
|
|
iBone = 0;
|
|
}
|
|
|
|
// Get Use Head Origin
|
|
CUtlVector< int > vecAttachments;
|
|
static CSchemaAttributeDefHandle pAttrDef_UseHead( "particle effect use head origin" );
|
|
uint32 iUseHead = 0;
|
|
if ( !pEconItem->FindAttribute( pAttrDef_UseHead, &iUseHead ) || !iUseHead == 0 )
|
|
{
|
|
// not using head? try searching for attachment points
|
|
for ( int i=0; i<ARRAYSIZE( pParticleSystem->pszControlPoints ); ++i )
|
|
{
|
|
const char *pszAttachmentName = pParticleSystem->pszControlPoints[i];
|
|
if ( pszAttachmentName && pszAttachmentName[0] )
|
|
{
|
|
int iAttachment = Studio_FindAttachment( pStudioHdr, pszAttachmentName );
|
|
if ( iAttachment < 0 )
|
|
continue;
|
|
|
|
vecAttachments.AddToTail( iAttachment );
|
|
}
|
|
}
|
|
}
|
|
|
|
static char pszFullname[256];
|
|
const char* pszSystemName = pParticleSystem->pszSystemName;
|
|
// Weapon Remap for a Base Effect to be used on a specific weapon
|
|
if ( pParticleSystem->bUseSuffixName && pEconItem && pEconItem->GetItemDefinition()->GetParticleSuffix() )
|
|
{
|
|
V_strcpy_safe( pszFullname, pParticleSystem->pszSystemName );
|
|
V_strcat_safe( pszFullname, "_" );
|
|
V_strcat_safe( pszFullname, pEconItem->GetItemDefinition()->GetParticleSuffix() );
|
|
pszSystemName = pszFullname;
|
|
}
|
|
|
|
// Update the Particles and render them
|
|
if ( m_aParticleSystems[ iSystem ] )
|
|
{
|
|
// Check if its a new particle system
|
|
if ( V_strcmp( m_aParticleSystems[ iSystem ]->m_pParticleSystem->GetName(), pszSystemName ) )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[ iSystem ] );
|
|
m_aParticleSystems[ iSystem ] = CreateParticleData( pszSystemName );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// create
|
|
m_aParticleSystems[ iSystem ] = CreateParticleData( pszSystemName );
|
|
}
|
|
|
|
// Particle system does not exist
|
|
if ( !m_aParticleSystems[ iSystem ] )
|
|
return false;
|
|
|
|
// Get offset if it exists (and if we're using head offset)
|
|
static CSchemaAttributeDefHandle pAttrDef_VerticalOffset( "particle effect vertical offset" );
|
|
uint32 iOffset = 0;
|
|
Vector vecParticleOffset( 0, 0, 0 );
|
|
if ( iUseHead > 0 && pEconItem->FindAttribute( pAttrDef_VerticalOffset, &iOffset ) )
|
|
{
|
|
vecParticleOffset.z = (float&)iOffset;
|
|
}
|
|
|
|
m_aParticleSystems[ iSystem ]->UpdateControlPoints( pStudioHdr, pWorldMatrix, vecAttachments, iBone, vecParticleOffset );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::UpdateEyeGlows(
|
|
IMatRenderContext *pRenderContext,
|
|
CStudioHdr *pStudioHdr,
|
|
MDLHandle_t mdlHandle,
|
|
matrix3x4_t *pWorldMatrix,
|
|
bool bIsRightEye
|
|
) {
|
|
float flOffset = 0;
|
|
modelpanel_particle_system_t eyeSystem = bIsRightEye ? SYSTEM_EYEGLOW_RIGHT : SYSTEM_EYEGLOW_LEFT;
|
|
modelpanel_particle_system_t sparkSystem = bIsRightEye ? SYSTEM_EYESPARK_RIGHT : SYSTEM_EYESPARK_LEFT;
|
|
const char* pszAttach = bIsRightEye ? "eyeglow_R" : "eyeglow_L";
|
|
|
|
// is this a model we care about?
|
|
int iAttachment = Studio_FindAttachment( pStudioHdr, pszAttach );
|
|
if ( iAttachment == INVALID_PARTICLE_ATTACHMENT || iAttachment == -1 )
|
|
return;
|
|
|
|
if ( m_bUpdateEyeGlows )
|
|
{
|
|
const char* pszGlowEffectName = m_pszEyeGlowParticleName;
|
|
|
|
// kill old effects
|
|
SafeDeleteParticleData( &m_aParticleSystems[ eyeSystem ] );
|
|
|
|
if ( !bIsRightEye && GetPlayerClass() == TF_CLASS_DEMOMAN )
|
|
{
|
|
// demo man has a green eyeglow for eyelander if applicable
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pPlayer )
|
|
{
|
|
int iDecaps = pPlayer->m_Shared.GetDecapitations();
|
|
pszGlowEffectName = pPlayer->GetDemomanEyeEffectName( iDecaps );
|
|
}
|
|
}
|
|
|
|
if ( pszGlowEffectName && pszGlowEffectName[0] != '\0' )
|
|
{
|
|
m_aParticleSystems[ eyeSystem ] = CreateParticleData( pszGlowEffectName );
|
|
}
|
|
}
|
|
|
|
if ( m_bPlaySparks && !m_vEyeGlowColor1.IsZero() )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[ sparkSystem ] );
|
|
|
|
// Generate an eye spark as well not for demo
|
|
m_aParticleSystems[ sparkSystem ] = CreateParticleData( "killstreak_t0_lvl1_flash" );
|
|
}
|
|
|
|
// Tick Update on position
|
|
if ( m_aParticleSystems[ eyeSystem ] || m_aParticleSystems[ sparkSystem ] )
|
|
{
|
|
// Figure out where our attach point is
|
|
matrix3x4_t matAttachToWorld;
|
|
|
|
CUtlVector< int > vecAttachments;
|
|
vecAttachments.AddToTail( iAttachment );
|
|
|
|
// Update control points which is updating the position of the particles
|
|
Vector vecForward;
|
|
MatrixGetColumn( matAttachToWorld, 0, vecForward );
|
|
|
|
Vector vecParticleOffset = vecForward * flOffset;
|
|
if ( m_aParticleSystems[ eyeSystem ] )
|
|
{
|
|
m_aParticleSystems[ eyeSystem ]->UpdateControlPoints( pStudioHdr, pWorldMatrix, vecAttachments, 0, vecParticleOffset );
|
|
}
|
|
|
|
if ( m_aParticleSystems[ sparkSystem ] )
|
|
{
|
|
m_aParticleSystems[ sparkSystem ]->UpdateControlPoints( pStudioHdr, pWorldMatrix, vecAttachments, 0, vecParticleOffset );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::UpdateActionSlotEffects(
|
|
IMatRenderContext *pRenderContext,
|
|
CStudioHdr *pStudioHdr,
|
|
MDLHandle_t mdlHandle,
|
|
matrix3x4_t *pWorldMatrix
|
|
) {
|
|
// is this a model we care about?
|
|
int iAttachment = Studio_FindAttachment( pStudioHdr, "effect_hand_R" );
|
|
if ( iAttachment == INVALID_PARTICLE_ATTACHMENT || iAttachment == -1 )
|
|
return;
|
|
|
|
if ( !m_bDrawActionSlotEffects )
|
|
return;
|
|
|
|
if ( !m_aParticleSystems[ SYSTEM_ACTIONSLOT ] )
|
|
{
|
|
m_aParticleSystems[ SYSTEM_ACTIONSLOT ] = CreateParticleData( CTFSpellBook::GetHandEffect( m_pHeldItem, 0 ) );
|
|
}
|
|
|
|
if ( !m_aParticleSystems[ SYSTEM_ACTIONSLOT ] )
|
|
return;
|
|
|
|
CUtlVector< int > vecAttachments;
|
|
vecAttachments.AddToTail( iAttachment );
|
|
|
|
m_aParticleSystems[ SYSTEM_ACTIONSLOT ]->UpdateControlPoints( pStudioHdr, pWorldMatrix, vecAttachments );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::UpdateTauntEffects(
|
|
IMatRenderContext *pRenderContext,
|
|
CStudioHdr *pStudioHdr,
|
|
MDLHandle_t mdlHandle,
|
|
matrix3x4_t *pWorldMatrix
|
|
) {
|
|
if ( !m_bDrawTauntParticles )
|
|
return;
|
|
|
|
if ( !m_aParticleSystems[SYSTEM_TAUNT] )
|
|
return;
|
|
|
|
// Check if refire is needed
|
|
if ( m_flTauntParticleRefireRate > 0 && m_flTauntParticleRefireTime < gpGlobals->curtime )
|
|
{
|
|
m_flTauntParticleRefireTime = gpGlobals->curtime + m_flTauntParticleRefireRate;
|
|
|
|
// safe off current particle name
|
|
CUtlString strParticleName = m_aParticleSystems[SYSTEM_TAUNT]->m_pParticleSystem->GetName();
|
|
|
|
// remove old particle
|
|
SafeDeleteParticleData( &m_aParticleSystems[SYSTEM_TAUNT] );
|
|
|
|
// create new particle
|
|
m_aParticleSystems[SYSTEM_TAUNT] = CreateParticleData( strParticleName.String() );
|
|
}
|
|
|
|
matrix3x4_t matAttachToWorld;
|
|
SetIdentityMatrix( matAttachToWorld );
|
|
|
|
CUtlVector< int > vecAttachments;
|
|
m_aParticleSystems[SYSTEM_TAUNT]->UpdateControlPoints( pStudioHdr, &matAttachToWorld, vecAttachments, 0, m_vecPlayerPos );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called Externally
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::SetEyeGlowEffect( const char *pEffectName, Vector vColor1, Vector vColor2, bool bForceUpdate, bool bPlaySparks )
|
|
{
|
|
m_vEyeGlowColor1 = vColor1;
|
|
m_vEyeGlowColor2 = vColor2;
|
|
m_bPlaySparks = bPlaySparks;
|
|
|
|
if ( bForceUpdate )
|
|
{
|
|
m_bUpdateEyeGlows = true;
|
|
}
|
|
|
|
if ( !pEffectName )
|
|
{
|
|
if ( m_pszEyeGlowParticleName[0] != '\0' )
|
|
{
|
|
m_bUpdateEyeGlows = true;
|
|
}
|
|
m_pszEyeGlowParticleName[0] = '\0';
|
|
}
|
|
else if ( !FStrEq( m_pszEyeGlowParticleName, pEffectName) )
|
|
{
|
|
V_strcpy_safe( m_pszEyeGlowParticleName, pEffectName );
|
|
m_bUpdateEyeGlows = true;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: clear all particles
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::InvalidateParticleEffects()
|
|
{
|
|
for ( int i=0; i<ARRAYSIZE(m_aParticleSystems); ++i )
|
|
{
|
|
if ( m_aParticleSystems[i] )
|
|
{
|
|
SafeDeleteParticleData( &m_aParticleSystems[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::StartEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
if ( !event || !event->GetActive() )
|
|
return;
|
|
|
|
CChoreoActor *actor = event->GetActor();
|
|
if ( actor && !actor->GetActive() )
|
|
return;
|
|
|
|
CChoreoChannel *channel = event->GetChannel();
|
|
if ( channel && !channel->GetActive() )
|
|
return;
|
|
|
|
//Msg( "Got STARTEVENT at %.2f\n", currenttime );
|
|
//Msg( "%8.4f: start %s\n", currenttime, event->GetDescription() );
|
|
|
|
switch ( event->GetType() )
|
|
{
|
|
case CChoreoEvent::SEQUENCE:
|
|
ProcessSequence( scene, event );
|
|
break;
|
|
|
|
case CChoreoEvent::SPEAK:
|
|
{
|
|
if ( m_bDisableSpeakEvent )
|
|
return;
|
|
|
|
// FIXME: dB hack. soundlevel needs to be moved into inside of wav?
|
|
soundlevel_t iSoundlevel = SNDLVL_TALKING;
|
|
if ( event->GetParameters2() )
|
|
{
|
|
iSoundlevel = (soundlevel_t)atoi( event->GetParameters2() );
|
|
if ( iSoundlevel == SNDLVL_NONE )
|
|
{
|
|
iSoundlevel = SNDLVL_TALKING;
|
|
}
|
|
}
|
|
|
|
float time_in_past = currenttime - event->GetStartTime() ;
|
|
float soundtime = gpGlobals->curtime - time_in_past;
|
|
|
|
EmitSound_t es;
|
|
es.m_nChannel = CHAN_VOICE;
|
|
es.m_flVolume = 1;
|
|
es.m_SoundLevel = iSoundlevel;
|
|
es.m_flSoundTime = soundtime;
|
|
es.m_bEmitCloseCaption = false;
|
|
es.m_pSoundName = event->GetParameters();
|
|
|
|
C_RecipientFilter filter;
|
|
C_BaseEntity::EmitSound( filter, SOUND_FROM_UI_PANEL, es );
|
|
}
|
|
break;
|
|
|
|
case CChoreoEvent::STOPPOINT:
|
|
{
|
|
// Nothing, this is a symbolic event for keeping the vcd alive for ramping out after the last true event
|
|
//ClearScene();
|
|
}
|
|
break;
|
|
|
|
case CChoreoEvent::LOOP:
|
|
ProcessLoop( scene, event );
|
|
break;
|
|
|
|
// Not supported in TF2's model previews
|
|
case CChoreoEvent::SUBSCENE:
|
|
case CChoreoEvent::SECTION:
|
|
{
|
|
Assert(0);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::EndEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
if ( !event || !event->GetActive() )
|
|
return;
|
|
|
|
CChoreoActor *actor = event->GetActor();
|
|
if ( actor && !actor->GetActive() )
|
|
return;
|
|
|
|
CChoreoChannel *channel = event->GetChannel();
|
|
if ( channel && !channel->GetActive() )
|
|
return;
|
|
|
|
//Msg( "Got ENDEVENT at %.2f\n", currenttime );
|
|
//Msg( "%8.4f: end %s %i\n", currenttime, event->GetDescription(), event->GetType() );
|
|
|
|
switch ( event->GetType() )
|
|
{
|
|
case CChoreoEvent::SUBSCENE:
|
|
{
|
|
// Not supported in TF2's model previews
|
|
Assert(0);
|
|
}
|
|
break;
|
|
case CChoreoEvent::SPEAK:
|
|
{
|
|
}
|
|
break;
|
|
case CChoreoEvent::STOPPOINT:
|
|
{
|
|
//SetSequenceLayers( NULL, 0 );
|
|
//ClearScene();
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
if ( !event || !event->GetActive() )
|
|
return;
|
|
|
|
CChoreoActor *actor = event->GetActor();
|
|
if ( actor && !actor->GetActive() )
|
|
return;
|
|
|
|
CChoreoChannel *channel = event->GetChannel();
|
|
if ( channel && !channel->GetActive() )
|
|
return;
|
|
|
|
//Msg("PROCESSEVENT at %.2f\n", currenttime );
|
|
|
|
switch( event->GetType() )
|
|
{
|
|
case CChoreoEvent::EXPRESSION:
|
|
if ( !m_bShouldRunFlexEvents )
|
|
{
|
|
ProcessFlexSettingSceneEvent( scene, event );
|
|
}
|
|
break;
|
|
|
|
case CChoreoEvent::FLEXANIMATION:
|
|
if ( m_bShouldRunFlexEvents )
|
|
{
|
|
ProcessFlexAnimation( scene, event );
|
|
}
|
|
break;
|
|
|
|
case CChoreoEvent::SEQUENCE:
|
|
case CChoreoEvent::SPEAK:
|
|
case CChoreoEvent::STOPPOINT:
|
|
// Nothing
|
|
break;
|
|
|
|
// Not supported in TF2's model previews
|
|
case CChoreoEvent::LOOKAT:
|
|
case CChoreoEvent::FACE:
|
|
case CChoreoEvent::SUBSCENE:
|
|
case CChoreoEvent::MOVETO:
|
|
case CChoreoEvent::INTERRUPT:
|
|
case CChoreoEvent::PERMIT_RESPONSES:
|
|
case CChoreoEvent::GESTURE:
|
|
Assert(0);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::CheckEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Apply a sequence
|
|
// Input : *event -
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessSequence( CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
Assert( event->GetType() == CChoreoEvent::SEQUENCE );
|
|
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
if ( !event->GetActor() )
|
|
return;
|
|
|
|
int iSequence = LookupSequence( &studioHdr, event->GetParameters() );
|
|
if (iSequence < 0)
|
|
return;
|
|
|
|
// making sure the mdl has correct playback rate
|
|
mstudioseqdesc_t &seqdesc = studioHdr.pSeqdesc( iSequence );
|
|
mstudioanimdesc_t &animdesc = studioHdr.pAnimdesc( studioHdr.iRelativeAnim( iSequence, seqdesc.anim(0,0) ) );
|
|
m_RootMDL.m_MDL.m_flPlaybackRate = animdesc.fps;
|
|
|
|
MDLSquenceLayer_t tmpSequenceLayers[1];
|
|
tmpSequenceLayers[0].m_nSequenceIndex = iSequence;
|
|
tmpSequenceLayers[0].m_flWeight = 1.0;
|
|
tmpSequenceLayers[0].m_bNoLoop = true;
|
|
tmpSequenceLayers[0].m_flCycleBeganAt = m_RootMDL.m_MDL.m_flTime;
|
|
SetSequenceLayers( tmpSequenceLayers, 1 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *scene -
|
|
// *event -
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessLoop( CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
Assert( event->GetType() == CChoreoEvent::LOOP );
|
|
|
|
float backtime = (float)atof( event->GetParameters() );
|
|
|
|
bool process = true;
|
|
int counter = event->GetLoopCount();
|
|
if ( counter != -1 )
|
|
{
|
|
int remaining = event->GetNumLoopsRemaining();
|
|
if ( remaining <= 0 )
|
|
{
|
|
process = false;
|
|
}
|
|
else
|
|
{
|
|
event->SetNumLoopsRemaining( --remaining );
|
|
}
|
|
}
|
|
|
|
if ( !process )
|
|
return;
|
|
|
|
//Msg("LOOP: %.2f (%.2f)\n", m_flSceneTime, scene->GetTime() );
|
|
|
|
float flPrevTime = m_flSceneTime;
|
|
scene->LoopToTime( backtime );
|
|
m_flSceneTime = backtime;
|
|
|
|
//Msg(" -> %.2f (%.2f)\n", m_flSceneTime, scene->GetTime() );
|
|
|
|
float flDelta = flPrevTime - backtime;
|
|
|
|
//Msg(" -> Delta %.2f\n", flDelta );
|
|
|
|
// If we're running noloop sequences, we need to push out their begin time, so they keep playing
|
|
for ( int i = 0; i < m_nNumSequenceLayers; i++ )
|
|
{
|
|
if ( m_SequenceLayers[i].m_bNoLoop )
|
|
{
|
|
m_SequenceLayers[i].m_flCycleBeganAt += flDelta;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
LocalFlexController_t CTFPlayerModelPanel::GetNumFlexControllers( void )
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
return studioHdr.numflexcontrollers();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CTFPlayerModelPanel::GetFlexDescFacs( int iFlexDesc )
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
mstudioflexdesc_t *pflexdesc = studioHdr.pFlexdesc( iFlexDesc );
|
|
|
|
return pflexdesc->pszFACS( );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CTFPlayerModelPanel::GetFlexControllerName( LocalFlexController_t iFlexController )
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
mstudioflexcontroller_t *pflexcontroller = studioHdr.pFlexcontroller( iFlexController );
|
|
|
|
return pflexcontroller->pszName( );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CTFPlayerModelPanel::GetFlexControllerType( LocalFlexController_t iFlexController )
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
mstudioflexcontroller_t *pflexcontroller = studioHdr.pFlexcontroller( iFlexController );
|
|
|
|
return pflexcontroller->pszType( );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
LocalFlexController_t CTFPlayerModelPanel::FindFlexController( const char *szName )
|
|
{
|
|
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
|
|
{
|
|
if (stricmp( GetFlexControllerName( i ), szName ) == 0)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
// AssertMsg( 0, UTIL_VarArgs( "flexcontroller %s couldn't be mapped!!!\n", szName ) );
|
|
return LocalFlexController_t(-1);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::SetFlexWeight( LocalFlexController_t index, float value )
|
|
{
|
|
if (index >= 0 && index < GetNumFlexControllers())
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
mstudioflexcontroller_t *pflexcontroller = studioHdr.pFlexcontroller( index );
|
|
|
|
if (pflexcontroller->max != pflexcontroller->min)
|
|
{
|
|
value = (value - pflexcontroller->min) / (pflexcontroller->max - pflexcontroller->min);
|
|
value = clamp( value, 0.0f, 1.0f );
|
|
}
|
|
|
|
m_flexWeight[ index ] = value;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
float CTFPlayerModelPanel::GetFlexWeight( LocalFlexController_t index )
|
|
{
|
|
if (index >= 0 && index < GetNumFlexControllers())
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
|
|
mstudioflexcontroller_t *pflexcontroller = studioHdr.pFlexcontroller( index );
|
|
|
|
if (pflexcontroller->max != pflexcontroller->min)
|
|
{
|
|
return m_flexWeight[index] * (pflexcontroller->max - pflexcontroller->min) + pflexcontroller->min;
|
|
}
|
|
|
|
return m_flexWeight[index];
|
|
}
|
|
return 0.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: During paint, apply the flex weights to the model
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::SetupFlexWeights( void )
|
|
{
|
|
if ( m_RootMDL.m_MDL.GetMDL() == MDLHANDLE_INVALID )
|
|
return;
|
|
|
|
// initialize the models local to global flex controller mappings
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
if (studioHdr.pFlexcontroller( LocalFlexController_t(0) )->localToGlobal == -1)
|
|
{
|
|
for ( LocalFlexController_t i = LocalFlexController_t(0); i < studioHdr.numflexcontrollers(); i++)
|
|
{
|
|
int j = C_BaseFlex::AddGlobalFlexController( studioHdr.pFlexcontroller( i )->pszName() );
|
|
studioHdr.pFlexcontroller( i )->localToGlobal = j;
|
|
}
|
|
}
|
|
|
|
int iControllers = GetNumFlexControllers();
|
|
for ( int j = 0; j < iControllers; j++ )
|
|
{
|
|
m_RootMDL.m_MDL.m_pFlexControls[j] = 0;
|
|
}
|
|
|
|
LocalFlexController_t i;
|
|
|
|
// Decay to neutral
|
|
for ( i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
|
|
{
|
|
SetFlexWeight( i, GetFlexWeight( i ) * 0.95 );
|
|
}
|
|
|
|
// Run scene
|
|
if ( m_pScene )
|
|
{
|
|
m_bShouldRunFlexEvents = true;
|
|
m_pScene->Think( m_flSceneTime );
|
|
}
|
|
|
|
// get the networked flexweights and convert them from 0..1 to real dynamic range
|
|
for (i = LocalFlexController_t(0); i < studioHdr.numflexcontrollers(); i++)
|
|
{
|
|
mstudioflexcontroller_t *pflex = studioHdr.pFlexcontroller( i );
|
|
|
|
m_RootMDL.m_MDL.m_pFlexControls[pflex->localToGlobal] = m_flexWeight[i];
|
|
// rescale
|
|
m_RootMDL.m_MDL.m_pFlexControls[pflex->localToGlobal] = m_RootMDL.m_MDL.m_pFlexControls[pflex->localToGlobal] * (pflex->max - pflex->min) + pflex->min;
|
|
}
|
|
|
|
if ( m_pScene )
|
|
{
|
|
m_bShouldRunFlexEvents = false;
|
|
m_pScene->Think( m_flSceneTime );
|
|
}
|
|
|
|
ProcessVisemes( m_PhonemeClasses );
|
|
|
|
if ( m_pScene )
|
|
{
|
|
// Advance time
|
|
if ( m_flLastTickTime < FLT_EPSILON )
|
|
{
|
|
m_flLastTickTime = m_RootMDL.m_MDL.m_flTime - 0.1;
|
|
}
|
|
|
|
m_flSceneTime += (m_RootMDL.m_MDL.m_flTime - m_flLastTickTime);
|
|
m_flLastTickTime = m_RootMDL.m_MDL.m_flTime;
|
|
|
|
if ( m_flSceneEndTime > FLT_EPSILON && m_flSceneTime > m_flSceneEndTime )
|
|
{
|
|
bool bLoopScene = m_bLoopScene;
|
|
char filename[MAX_PATH];
|
|
V_strcpy_safe( filename, m_pScene->GetFilename() );
|
|
|
|
SetSequenceLayers( NULL, 0 );
|
|
ClearScene();
|
|
|
|
if ( bLoopScene )
|
|
{
|
|
m_pScene = LoadSceneForModel( filename, this, &m_flSceneEndTime );
|
|
}
|
|
else
|
|
{
|
|
m_pszVCD = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern CFlexSceneFileManager g_FlexSceneFileManager;
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessExpression( CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
// Flexanimations have to have an end time!!!
|
|
if ( !event->HasEndTime() )
|
|
return;
|
|
|
|
// Look up the actual strings
|
|
const char *scenefile = event->GetParameters();
|
|
const char *name = event->GetParameters2();
|
|
|
|
// Have to find both strings
|
|
if ( scenefile && name )
|
|
{
|
|
// Find the scene file
|
|
const flexsettinghdr_t *pExpHdr = ( const flexsettinghdr_t * )g_FlexSceneFileManager.FindSceneFile( this, scenefile, true );
|
|
if ( pExpHdr )
|
|
{
|
|
float scenetime = scene->GetTime();
|
|
|
|
float flIntensity = event->GetIntensity( scenetime );
|
|
|
|
int i;
|
|
const flexsetting_t *pSetting = NULL;
|
|
|
|
// Find the named setting in the base
|
|
for ( i = 0; i < pExpHdr->numflexsettings; i++ )
|
|
{
|
|
pSetting = pExpHdr->pSetting( i );
|
|
if ( !pSetting )
|
|
continue;
|
|
|
|
if ( !V_stricmp( pSetting->pszName(), name ) )
|
|
break;
|
|
}
|
|
|
|
if ( i>=pExpHdr->numflexsettings )
|
|
return;
|
|
|
|
flexweight_t *pWeights = NULL;
|
|
int truecount = pSetting->psetting( (byte *)pExpHdr, 0, &pWeights );
|
|
if ( !pWeights )
|
|
return;
|
|
|
|
for (i = 0; i < truecount; i++, pWeights++)
|
|
{
|
|
int j = FlexControllerLocalToGlobal( pExpHdr, pWeights->key );
|
|
|
|
float s = clamp( pWeights->influence * flIntensity, 0.0f, 1.0f );
|
|
m_RootMDL.m_MDL.m_pFlexControls[ j ] = m_RootMDL.m_MDL.m_pFlexControls[j] * (1.0f - s) + pWeights->weight * s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessFlexSettingSceneEvent( CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
// Flexanimations have to have an end time!!!
|
|
if ( !event->HasEndTime() )
|
|
return;
|
|
|
|
VPROF( "C_BaseFlex::ProcessFlexSettingSceneEvent" );
|
|
|
|
// Look up the actual strings
|
|
const char *scenefile = event->GetParameters();
|
|
const char *name = event->GetParameters2();
|
|
|
|
// Have to find both strings
|
|
if ( scenefile && name )
|
|
{
|
|
// Find the scene file
|
|
const flexsettinghdr_t *pExpHdr = ( const flexsettinghdr_t * )g_FlexSceneFileManager.FindSceneFile( this, scenefile, true );
|
|
if ( pExpHdr )
|
|
{
|
|
float scenetime = scene->GetTime();
|
|
|
|
float scale = event->GetIntensity( scenetime );
|
|
|
|
// Add the named expression
|
|
AddFlexSetting( name, scale, pExpHdr );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *expr -
|
|
// scale -
|
|
// *pSettinghdr -
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::AddFlexSetting( const char *expr, float scale, const flexsettinghdr_t *pSettinghdr )
|
|
{
|
|
int i;
|
|
const flexsetting_t *pSetting = NULL;
|
|
|
|
// Find the named setting in the base
|
|
for ( i = 0; i < pSettinghdr->numflexsettings; i++ )
|
|
{
|
|
pSetting = pSettinghdr->pSetting( i );
|
|
if ( !pSetting )
|
|
continue;
|
|
|
|
const char *name = pSetting->pszName();
|
|
|
|
if ( !V_stricmp( name, expr ) )
|
|
break;
|
|
}
|
|
|
|
if ( i>=pSettinghdr->numflexsettings )
|
|
{
|
|
return;
|
|
}
|
|
|
|
flexweight_t *pWeights = NULL;
|
|
int truecount = pSetting->psetting( (byte *)pSettinghdr, 0, &pWeights );
|
|
if ( !pWeights )
|
|
return;
|
|
|
|
for (i = 0; i < truecount; i++, pWeights++)
|
|
{
|
|
// Translate to local flex controller
|
|
// this is translating from the settings's local index to the models local index
|
|
int index = FlexControllerLocalToGlobal( pSettinghdr, pWeights->key );
|
|
|
|
// blend scaled weighting in to total (post networking g_flexweight!!!!)
|
|
float s = clamp( scale * pWeights->influence, 0.0f, 1.0f );
|
|
m_RootMDL.m_MDL.m_pFlexControls[index] = m_RootMDL.m_MDL.m_pFlexControls[index] * (1.0f - s) + pWeights->weight * s;
|
|
|
|
for ( int iMergeMDL=0; iMergeMDL<m_aMergeMDLs.Count(); ++iMergeMDL )
|
|
{
|
|
m_aMergeMDLs[iMergeMDL].m_MDL.m_pFlexControls[index] = m_aMergeMDLs[iMergeMDL].m_MDL.m_pFlexControls[index] * (1.0f - s) + pWeights->weight * s;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Apply flexanimation to actor's face
|
|
// Input : *event -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessFlexAnimation( CChoreoScene *scene, CChoreoEvent *event )
|
|
{
|
|
Assert( event->GetType() == CChoreoEvent::FLEXANIMATION );
|
|
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
CStudioHdr *hdr = &studioHdr;
|
|
if ( !hdr )
|
|
return;
|
|
|
|
if ( !event->GetTrackLookupSet() )
|
|
{
|
|
// Create lookup data
|
|
for ( int i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
|
|
{
|
|
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
|
|
if ( !track )
|
|
continue;
|
|
|
|
if ( track->IsComboType() )
|
|
{
|
|
char name[ 512 ];
|
|
Q_strncpy( name, "right_" ,sizeof(name));
|
|
Q_strncat( name, track->GetFlexControllerName(),sizeof(name), COPY_ALL_CHARACTERS );
|
|
|
|
track->SetFlexControllerIndex( MAX( FindFlexController( name ), LocalFlexController_t(0) ), 0, 0 );
|
|
|
|
Q_strncpy( name, "left_" ,sizeof(name));
|
|
Q_strncat( name, track->GetFlexControllerName(),sizeof(name), COPY_ALL_CHARACTERS );
|
|
|
|
track->SetFlexControllerIndex( MAX( FindFlexController( name ), LocalFlexController_t(0) ), 0, 1 );
|
|
}
|
|
else
|
|
{
|
|
track->SetFlexControllerIndex( MAX( FindFlexController( (char *)track->GetFlexControllerName() ), LocalFlexController_t(0)), 0 );
|
|
}
|
|
}
|
|
|
|
event->SetTrackLookupSet( true );
|
|
}
|
|
|
|
float scenetime = scene->GetTime();
|
|
|
|
float weight = event->GetIntensity( scenetime );
|
|
|
|
// Iterate animation tracks
|
|
for ( int i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
|
|
{
|
|
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
|
|
if ( !track )
|
|
continue;
|
|
|
|
// Disabled
|
|
if ( !track->IsTrackActive() )
|
|
continue;
|
|
|
|
// Map track flex controller to global name
|
|
if ( track->IsComboType() )
|
|
{
|
|
for ( int side = 0; side < 2; side++ )
|
|
{
|
|
LocalFlexController_t controller = track->GetRawFlexControllerIndex( side );
|
|
|
|
// Get spline intensity for controller
|
|
float flIntensity = track->GetIntensity( scenetime, side );
|
|
if ( controller >= LocalFlexController_t(0) )
|
|
{
|
|
float orig = GetFlexWeight( controller );
|
|
float value = orig * (1 - weight) + flIntensity * weight;
|
|
SetFlexWeight( controller, value );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LocalFlexController_t controller = track->GetRawFlexControllerIndex( 0 );
|
|
|
|
// Get spline intensity for controller
|
|
float flIntensity = track->GetIntensity( scenetime, 0 );
|
|
if ( controller >= LocalFlexController_t(0) )
|
|
{
|
|
float orig = GetFlexWeight( controller );
|
|
float value = orig * (1 - weight) + flIntensity * weight;
|
|
SetFlexWeight( controller, value );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern ConVar g_CV_PhonemeDelay;
|
|
extern ConVar g_CV_PhonemeFilter;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ProcessVisemes( Emphasized_Phoneme *classes )
|
|
{
|
|
// Any sounds being played?
|
|
if ( !MouthInfo().IsActive() )
|
|
return;
|
|
|
|
// Multiple phoneme tracks can overlap, look across all such tracks.
|
|
for ( int source = 0 ; source < MouthInfo().GetNumVoiceSources(); source++ )
|
|
{
|
|
CVoiceData *vd = MouthInfo().GetVoiceSource( source );
|
|
if ( !vd || vd->ShouldIgnorePhonemes() )
|
|
continue;
|
|
|
|
CSentence *sentence = engine->GetSentence( vd->GetSource() );
|
|
if ( !sentence )
|
|
continue;
|
|
|
|
float sentence_length = engine->GetSentenceLength( vd->GetSource() );
|
|
float timesincestart = vd->GetElapsedTime();
|
|
|
|
// This sound should be done...why hasn't it been removed yet???
|
|
if ( timesincestart >= ( sentence_length + 2.0f ) )
|
|
continue;
|
|
|
|
// Adjust actual time
|
|
float t = timesincestart - g_CV_PhonemeDelay.GetFloat();
|
|
|
|
// Get box filter duration
|
|
float dt = g_CV_PhonemeFilter.GetFloat();
|
|
|
|
// Streaming sounds get an additional delay...
|
|
/*
|
|
// Tracker 20534: Probably not needed any more with the async sound stuff that
|
|
// we now have (we don't have a disk i/o hitch on startup which might have been
|
|
// messing up the startup timing a bit )
|
|
bool streaming = engine->IsStreaming( vd->m_pAudioSource );
|
|
if ( streaming )
|
|
{
|
|
t -= g_CV_PhonemeDelayStreaming.GetFloat();
|
|
}
|
|
*/
|
|
|
|
// Assume sound has been playing for a while...
|
|
bool juststarted = false;
|
|
|
|
// Get intensity setting for this time (from spline)
|
|
float emphasis_intensity = sentence->GetIntensity( t, sentence_length );
|
|
|
|
// Blend and add visemes together
|
|
AddVisemesForSentence( classes, emphasis_intensity, sentence, t, dt, juststarted );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::AddVisemesForSentence( Emphasized_Phoneme *classes, float emphasis_intensity, CSentence *sentence, float t, float dt, bool juststarted )
|
|
{
|
|
int pcount = sentence->GetRuntimePhonemeCount();
|
|
for ( int k = 0; k < pcount; k++ )
|
|
{
|
|
const CBasePhonemeTag *phoneme = sentence->GetRuntimePhoneme( k );
|
|
|
|
if (t > phoneme->GetStartTime() && t < phoneme->GetEndTime())
|
|
{
|
|
bool bCrossfade = true;
|
|
if (bCrossfade)
|
|
{
|
|
if (k < pcount-1)
|
|
{
|
|
const CBasePhonemeTag *next = sentence->GetRuntimePhoneme( k + 1 );
|
|
// if I have a neighbor
|
|
if ( next )
|
|
{
|
|
// and they're touching
|
|
if (next->GetStartTime() == phoneme->GetEndTime() )
|
|
{
|
|
// no gap, so increase the blend length to the end of the next phoneme, as long as it's not longer than the current phoneme
|
|
dt = MAX( dt, MIN( next->GetEndTime() - t, phoneme->GetEndTime() - phoneme->GetStartTime() ) );
|
|
}
|
|
else
|
|
{
|
|
// dead space, so increase the blend length to the start of the next phoneme, as long as it's not longer than the current phoneme
|
|
dt = MAX( dt, MIN( next->GetStartTime() - t, phoneme->GetEndTime() - phoneme->GetStartTime() ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// last phoneme in list, increase the blend length to the length of the current phoneme
|
|
dt = MAX( dt, phoneme->GetEndTime() - phoneme->GetStartTime() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
float t1 = ( phoneme->GetStartTime() - t) / dt;
|
|
float t2 = ( phoneme->GetEndTime() - t) / dt;
|
|
|
|
if (t1 < 1.0 && t2 > 0)
|
|
{
|
|
float scale;
|
|
|
|
// clamp
|
|
if (t2 > 1)
|
|
t2 = 1;
|
|
if (t1 < 0)
|
|
t1 = 0;
|
|
|
|
// FIXME: simple box filter. Should use something fancier
|
|
scale = (t2 - t1);
|
|
|
|
AddViseme( classes, emphasis_intensity, phoneme->GetPhonemeCode(), scale, juststarted );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *classes -
|
|
// phoneme -
|
|
// scale -
|
|
// newexpression -
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::AddViseme( Emphasized_Phoneme *classes, float emphasis_intensity, int phoneme, float scale, bool newexpression )
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
CStudioHdr *hdr = &studioHdr;
|
|
if ( !hdr )
|
|
return;
|
|
|
|
int type;
|
|
|
|
// Setup weights for any emphasis blends
|
|
bool skip = SetupEmphasisBlend( classes, phoneme );
|
|
|
|
phoneme = 230;
|
|
scale = 1.0;
|
|
|
|
// Uh-oh, missing or unknown phoneme???
|
|
if ( skip )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Compute blend weights
|
|
ComputeBlendedSetting( classes, emphasis_intensity );
|
|
|
|
for ( type = 0; type < NUM_PHONEME_CLASSES; type++ )
|
|
{
|
|
Emphasized_Phoneme *info = &classes[ type ];
|
|
if ( !info->valid || info->amount == 0.0f )
|
|
continue;
|
|
|
|
const flexsettinghdr_t *actual_flexsetting_header = info->base;
|
|
const flexsetting_t *pSetting = actual_flexsetting_header->pIndexedSetting( phoneme );
|
|
if (!pSetting)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
flexweight_t *pWeights = NULL;
|
|
|
|
int truecount = pSetting->psetting( (byte *)actual_flexsetting_header, 0, &pWeights );
|
|
if ( pWeights )
|
|
{
|
|
for ( int i = 0; i < truecount; i++)
|
|
{
|
|
// Translate to global controller number
|
|
int j = FlexControllerLocalToGlobal( actual_flexsetting_header, pWeights->key );
|
|
// Add scaled weighting in
|
|
if ( pWeights->weight > 0 )
|
|
{
|
|
m_RootMDL.m_MDL.m_pFlexControls[j] += info->amount * scale * pWeights->weight;
|
|
}
|
|
// Go to next setting
|
|
pWeights++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A lot of the one time setup and also resets amount to 0.0f default
|
|
// for strong/weak/normal tracks
|
|
// Returning true == skip this phoneme
|
|
// Input : *classes -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFPlayerModelPanel::SetupEmphasisBlend( Emphasized_Phoneme *classes, int phoneme )
|
|
{
|
|
int i;
|
|
|
|
bool skip = false;
|
|
|
|
for ( i = 0; i < NUM_PHONEME_CLASSES; i++ )
|
|
{
|
|
Emphasized_Phoneme *info = &classes[ i ];
|
|
|
|
// Assume it's bogus
|
|
info->valid = false;
|
|
info->amount = 0.0f;
|
|
|
|
// One time setup
|
|
if ( !info->basechecked )
|
|
{
|
|
info->basechecked = true;
|
|
info->base = (flexsettinghdr_t *)g_FlexSceneFileManager.FindSceneFile( this, info->classname, false );
|
|
}
|
|
info->exp = NULL;
|
|
if ( info->base )
|
|
{
|
|
Assert( info->base->id == ('V' << 16) + ('F' << 8) + ('E') );
|
|
info->exp = info->base->pIndexedSetting( phoneme );
|
|
}
|
|
|
|
if ( info->required && ( !info->base || !info->exp ) )
|
|
{
|
|
skip = true;
|
|
break;
|
|
}
|
|
|
|
if ( info->exp )
|
|
{
|
|
info->valid = true;
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
#define STRONG_CROSSFADE_START 0.60f
|
|
#define WEAK_CROSSFADE_START 0.40f
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Here's the formula
|
|
// 0.5 is neutral 100 % of the default setting
|
|
// Crossfade starts at STRONG_CROSSFADE_START and is full at STRONG_CROSSFADE_END
|
|
// If there isn't a strong then the intensity of the underlying phoneme is fixed at 2 x STRONG_CROSSFADE_START
|
|
// so we don't get huge numbers
|
|
// Input : *classes -
|
|
// emphasis_intensity -
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::ComputeBlendedSetting( Emphasized_Phoneme *classes, float emphasis_intensity )
|
|
{
|
|
// See which blends are available for the current phoneme
|
|
bool has_weak = classes[ PHONEME_CLASS_WEAK ].valid;
|
|
bool has_strong = classes[ PHONEME_CLASS_STRONG ].valid;
|
|
|
|
// Better have phonemes in general
|
|
Assert( classes[ PHONEME_CLASS_NORMAL ].valid );
|
|
|
|
if ( emphasis_intensity > STRONG_CROSSFADE_START )
|
|
{
|
|
if ( has_strong )
|
|
{
|
|
// Blend in some of strong
|
|
float dist_remaining = 1.0f - emphasis_intensity;
|
|
float frac = dist_remaining / ( 1.0f - STRONG_CROSSFADE_START );
|
|
|
|
classes[ PHONEME_CLASS_NORMAL ].amount = (frac) * 2.0f * STRONG_CROSSFADE_START;
|
|
classes[ PHONEME_CLASS_STRONG ].amount = 1.0f - frac;
|
|
}
|
|
else
|
|
{
|
|
emphasis_intensity = MIN( emphasis_intensity, STRONG_CROSSFADE_START );
|
|
classes[ PHONEME_CLASS_NORMAL ].amount = 2.0f * emphasis_intensity;
|
|
}
|
|
}
|
|
else if ( emphasis_intensity < WEAK_CROSSFADE_START )
|
|
{
|
|
if ( has_weak )
|
|
{
|
|
// Blend in some weak
|
|
float dist_remaining = WEAK_CROSSFADE_START - emphasis_intensity;
|
|
float frac = dist_remaining / ( WEAK_CROSSFADE_START );
|
|
|
|
classes[ PHONEME_CLASS_NORMAL ].amount = (1.0f - frac) * 2.0f * WEAK_CROSSFADE_START;
|
|
classes[ PHONEME_CLASS_WEAK ].amount = frac;
|
|
}
|
|
else
|
|
{
|
|
emphasis_intensity = MAX( emphasis_intensity, WEAK_CROSSFADE_START );
|
|
classes[ PHONEME_CLASS_NORMAL ].amount = 2.0f * emphasis_intensity;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Assume 0.5 (neutral) becomes a scaling of 1.0f
|
|
classes[ PHONEME_CLASS_NORMAL ].amount = 2.0f * emphasis_intensity;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::InitPhonemeMappings( void )
|
|
{
|
|
CStudioHdr studioHdr( GetStudioHdr(), g_pMDLCache );
|
|
if ( studioHdr.IsValid() )
|
|
{
|
|
char szBasename[MAX_PATH];
|
|
Q_StripExtension( studioHdr.pszName(), szBasename, sizeof( szBasename ) );
|
|
|
|
char szExpressionName[MAX_PATH];
|
|
Q_snprintf( szExpressionName, sizeof( szExpressionName ), "%s/phonemes/phonemes", szBasename );
|
|
if ( g_FlexSceneFileManager.FindSceneFile( this, szExpressionName, false ) )
|
|
{
|
|
SetupMappings( szExpressionName );
|
|
return;
|
|
}
|
|
}
|
|
|
|
SetupMappings( "phonemes" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::SetupMappings( char const *pchFileRoot )
|
|
{
|
|
// Fill in phoneme class lookup
|
|
memset( m_PhonemeClasses, 0, sizeof( m_PhonemeClasses ) );
|
|
|
|
Emphasized_Phoneme *normal = &m_PhonemeClasses[ PHONEME_CLASS_NORMAL ];
|
|
Q_snprintf( normal->classname, sizeof( normal->classname ), "%s", pchFileRoot );
|
|
normal->required = true;
|
|
|
|
Emphasized_Phoneme *weak = &m_PhonemeClasses[ PHONEME_CLASS_WEAK ];
|
|
Q_snprintf( weak->classname, sizeof( weak->classname ), "%s_weak", pchFileRoot );
|
|
Emphasized_Phoneme *strong = &m_PhonemeClasses[ PHONEME_CLASS_STRONG ];
|
|
Q_snprintf( strong->classname, sizeof( strong->classname ), "%s_strong", pchFileRoot );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Since everyone shared a pSettinghdr now, we need to set up the localtoglobal mapping per entity, but
|
|
// we just do this in memory with an array of integers (could be shorts, I suppose)
|
|
// Input : *pSettinghdr -
|
|
//-----------------------------------------------------------------------------
|
|
void CTFPlayerModelPanel::EnsureTranslations( const flexsettinghdr_t *pSettinghdr )
|
|
{
|
|
Assert( pSettinghdr );
|
|
|
|
FS_LocalToGlobal_t entry( pSettinghdr );
|
|
|
|
unsigned short idx = m_LocalToGlobal.Find( entry );
|
|
if ( idx != m_LocalToGlobal.InvalidIndex() )
|
|
return;
|
|
|
|
entry.SetCount( pSettinghdr->numkeys );
|
|
|
|
for ( int i = 0; i < pSettinghdr->numkeys; ++i )
|
|
{
|
|
entry.m_Mapping[ i ] = C_BaseFlex::AddGlobalFlexController( pSettinghdr->pLocalName( i ) );
|
|
}
|
|
|
|
m_LocalToGlobal.Insert( entry );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Look up instance specific mapping
|
|
// Input : *pSettinghdr -
|
|
// key -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CTFPlayerModelPanel::FlexControllerLocalToGlobal( const flexsettinghdr_t *pSettinghdr, int key )
|
|
{
|
|
FS_LocalToGlobal_t entry( pSettinghdr );
|
|
|
|
int idx = m_LocalToGlobal.Find( entry );
|
|
if ( idx == m_LocalToGlobal.InvalidIndex() )
|
|
{
|
|
// This should never happen!!!
|
|
Assert( 0 );
|
|
Warning( "Unable to find mapping for flexcontroller %i, settings %p on CTFPlayerModelPanel\n", key, pSettinghdr );
|
|
EnsureTranslations( pSettinghdr );
|
|
idx = m_LocalToGlobal.Find( entry );
|
|
if ( idx == m_LocalToGlobal.InvalidIndex() )
|
|
{
|
|
Error( "CTFPlayerModelPanel::FlexControllerLocalToGlobal failed!\n" );
|
|
}
|
|
}
|
|
|
|
FS_LocalToGlobal_t& result = m_LocalToGlobal[ idx ];
|
|
// Validate lookup
|
|
Assert( result.m_nCount != 0 && key < result.m_nCount );
|
|
int index = result.m_Mapping[ key ];
|
|
return index;
|
|
}
|
|
|