546 lines
15 KiB
C++
546 lines
15 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Controls the pose parameters of a model
|
|
//
|
|
//===========================================================================//
|
|
|
|
|
|
#include "cbase.h"
|
|
#include "point_posecontroller.h"
|
|
|
|
|
|
#ifndef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// SERVER CLASS
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "baseanimating.h"
|
|
#include "props.h"
|
|
|
|
|
|
#define MAX_POSE_INTERPOLATION_TIME 10.0f
|
|
#define MAX_POSE_CYCLE_FREQUENCY 10.0f
|
|
#define MAX_POSE_FMOD_RATE 10.0f
|
|
#define MAX_POSE_FMOD_AMPLITUDE 10.0f
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( point_posecontroller, CPoseController );
|
|
|
|
|
|
BEGIN_DATADESC( CPoseController )
|
|
DEFINE_AUTO_ARRAY( m_hProps, FIELD_EHANDLE ),
|
|
DEFINE_AUTO_ARRAY( m_chPoseIndex, FIELD_CHARACTER ),
|
|
DEFINE_FIELD( m_bDisablePropLookup, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bPoseValueParity, FIELD_BOOLEAN ),
|
|
// Keys
|
|
DEFINE_KEYFIELD( m_iszPropName, FIELD_STRING, "PropName" ),
|
|
DEFINE_KEYFIELD( m_iszPoseParameterName, FIELD_STRING, "PoseParameterName" ),
|
|
DEFINE_KEYFIELD( m_fPoseValue, FIELD_FLOAT, "PoseValue" ),
|
|
DEFINE_KEYFIELD( m_fInterpolationTime, FIELD_FLOAT, "InterpolationTime" ),
|
|
DEFINE_KEYFIELD( m_bInterpolationWrap, FIELD_BOOLEAN, "InterpolationWrap" ),
|
|
DEFINE_KEYFIELD( m_fCycleFrequency, FIELD_FLOAT, "CycleFrequency" ),
|
|
DEFINE_KEYFIELD( m_nFModType, FIELD_INTEGER, "FModType" ),
|
|
DEFINE_KEYFIELD( m_fFModTimeOffset, FIELD_FLOAT, "FModTimeOffset" ),
|
|
DEFINE_KEYFIELD( m_fFModRate, FIELD_FLOAT, "FModRate" ),
|
|
DEFINE_KEYFIELD( m_fFModAmplitude, FIELD_FLOAT, "FModAmplitude" ),
|
|
// Functions
|
|
DEFINE_FUNCTION( Think ),
|
|
// Inputs
|
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetPoseParameterName", InputSetPoseParameterName ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetPoseValue", InputSetPoseValue ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetInterpolationTime", InputSetInterpolationTime ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetCycleFrequency", InputSetCycleFrequency ),
|
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetFModType", InputSetFModType ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFModTimeOffset", InputSetFModTimeOffset ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFModRate", InputSetFModRate ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetFModAmplitude", InputSetFModAmplitude ),
|
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "RandomizeFMod", InputRandomizeFMod ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "GetFMod", InputGetFMod ),
|
|
END_DATADESC()
|
|
|
|
|
|
IMPLEMENT_SERVERCLASS_ST(CPoseController, DT_PoseController)
|
|
SendPropArray3( SENDINFO_ARRAY3(m_hProps), SendPropEHandle( SENDINFO_ARRAY(m_hProps) ) ),
|
|
SendPropArray3( SENDINFO_ARRAY3(m_chPoseIndex), SendPropInt( SENDINFO_ARRAY(m_chPoseIndex), 5, SPROP_UNSIGNED ) ), // bits sent must be enough to represent MAXSTUDIOPOSEPARAM
|
|
SendPropBool( SENDINFO(m_bPoseValueParity) ),
|
|
SendPropFloat( SENDINFO(m_fPoseValue), 11, 0, 0.0f, 1.0f ),
|
|
SendPropFloat( SENDINFO(m_fInterpolationTime), 11, 0, 0.0f, MAX_POSE_INTERPOLATION_TIME ),
|
|
SendPropBool( SENDINFO(m_bInterpolationWrap) ),
|
|
SendPropFloat( SENDINFO(m_fCycleFrequency), 11, 0, -MAX_POSE_CYCLE_FREQUENCY, MAX_POSE_CYCLE_FREQUENCY ),
|
|
SendPropInt( SENDINFO(m_nFModType), 3, SPROP_UNSIGNED ),
|
|
SendPropFloat( SENDINFO(m_fFModTimeOffset), 11, 0, -1.0f, 1.0f ),
|
|
SendPropFloat( SENDINFO(m_fFModRate), 11, 0, -MAX_POSE_FMOD_RATE, MAX_POSE_FMOD_RATE ),
|
|
SendPropFloat( SENDINFO(m_fFModAmplitude), 11, 0, 0.0f, MAX_POSE_FMOD_AMPLITUDE ),
|
|
END_SEND_TABLE()
|
|
|
|
|
|
void CPoseController::Spawn( void )
|
|
{
|
|
BaseClass::Spawn();
|
|
|
|
// Talk to the client class when data changes
|
|
AddEFlags( EFL_FORCE_CHECK_TRANSMIT );
|
|
|
|
// Think to refresh the list of models
|
|
SetThink( &CPoseController::Think );
|
|
SetNextThink( gpGlobals->curtime + 1.0 );
|
|
}
|
|
|
|
void CPoseController::Think( void )
|
|
{
|
|
if ( !m_bDisablePropLookup )
|
|
{
|
|
// Refresh the list of models
|
|
BuildPropList();
|
|
|
|
SetCurrentPose( m_fPoseValue );
|
|
|
|
m_bDisablePropLookup = true;
|
|
|
|
SetNextThink( gpGlobals->curtime + 1.0 );
|
|
}
|
|
}
|
|
|
|
void CPoseController::BuildPropList( void )
|
|
{
|
|
int iPropNum = 0;
|
|
CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, m_iszPropName );
|
|
|
|
while ( pEnt && iPropNum < MAX_POSE_CONTROLLED_PROPS )
|
|
{
|
|
CBaseAnimating *pProp = dynamic_cast<CBaseAnimating*>( pEnt );
|
|
if ( pProp )
|
|
{
|
|
CDynamicProp *pDynamicProp = dynamic_cast<CDynamicProp*>( pProp );
|
|
if ( pDynamicProp )
|
|
pDynamicProp->PropSetSequence( 0 );
|
|
|
|
if ( m_hProps[ iPropNum ] != pProp )
|
|
{
|
|
// Only set new handles (to avoid network spam)
|
|
m_hProps.Set( iPropNum, pProp );
|
|
}
|
|
|
|
// Update the pose parameter index
|
|
SetPoseIndex( iPropNum, pProp->LookupPoseParameter( m_iszPoseParameterName.ToCStr() ) );
|
|
|
|
++iPropNum;
|
|
}
|
|
|
|
// Get the next entity with specified targetname
|
|
pEnt = gEntList.FindEntityByName( pEnt, m_iszPropName );
|
|
}
|
|
|
|
// Nullify the remaining handles
|
|
while ( iPropNum < MAX_POSE_CONTROLLED_PROPS )
|
|
{
|
|
if ( m_hProps[ iPropNum ] != NULL )
|
|
m_hProps.Set( iPropNum, NULL );
|
|
|
|
++iPropNum;
|
|
}
|
|
|
|
SetNextThink( gpGlobals->curtime + 1.0 );
|
|
}
|
|
|
|
void CPoseController::BuildPoseIndexList( void )
|
|
{
|
|
for ( int iPropNum = 0; iPropNum < MAX_POSE_CONTROLLED_PROPS; ++iPropNum )
|
|
{
|
|
CBaseAnimating *pProp = dynamic_cast<CBaseAnimating*>( m_hProps[ iPropNum ].Get() );
|
|
|
|
if ( pProp )
|
|
{
|
|
// Update the pose parameter index
|
|
SetPoseIndex( iPropNum, pProp->LookupPoseParameter( m_iszPoseParameterName.ToCStr() ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPoseController::SetPoseIndex( int i, int iValue )
|
|
{
|
|
if ( iValue == -1 )
|
|
{
|
|
// Using this as invalid lets us network less bits
|
|
iValue = MAXSTUDIOPOSEPARAM;
|
|
}
|
|
|
|
if ( m_chPoseIndex[ i ] != iValue )
|
|
{
|
|
// Only set a new index (to avoid network spam)
|
|
m_chPoseIndex.Set( i, iValue );
|
|
}
|
|
}
|
|
|
|
float CPoseController::GetPoseValue( void )
|
|
{
|
|
return m_fPoseValue;
|
|
}
|
|
|
|
void CPoseController::SetProp( CBaseAnimating *pProp )
|
|
{
|
|
// Control a prop directly by pointer
|
|
if ( m_hProps[ 0 ] != pProp )
|
|
{
|
|
// Only set new handles (to avoid network spam)
|
|
m_hProps.Set( 0, pProp );
|
|
}
|
|
|
|
// Update the pose parameter index
|
|
SetPoseIndex( 0, pProp->LookupPoseParameter( m_iszPoseParameterName.ToCStr() ) );
|
|
|
|
// Nullify the remaining handles
|
|
for ( int iPropNum = 1; iPropNum < MAX_POSE_CONTROLLED_PROPS; ++iPropNum )
|
|
{
|
|
if ( m_hProps[ iPropNum ] != NULL )
|
|
m_hProps.Set( iPropNum, NULL );
|
|
}
|
|
|
|
m_bDisablePropLookup = false;
|
|
}
|
|
|
|
void CPoseController::SetPropName( const char *pName )
|
|
{
|
|
m_iszPropName = MAKE_STRING( pName );
|
|
|
|
BuildPropList();
|
|
}
|
|
|
|
void CPoseController::SetPoseParameterName( const char *pName )
|
|
{
|
|
m_iszPoseParameterName = MAKE_STRING( pName );
|
|
|
|
BuildPoseIndexList();
|
|
}
|
|
|
|
void CPoseController::SetPoseValue( float fValue )
|
|
{
|
|
m_fPoseValue = clamp( fValue, 0.0f, 1.0f );
|
|
|
|
// Force the client to set the current pose
|
|
m_bPoseValueParity = !m_bPoseValueParity;
|
|
|
|
SetCurrentPose( m_fPoseValue );
|
|
}
|
|
|
|
void CPoseController::SetInterpolationTime( float fValue )
|
|
{
|
|
m_fInterpolationTime = clamp( fValue, 0.0f, MAX_POSE_INTERPOLATION_TIME );
|
|
}
|
|
|
|
void CPoseController::SetInterpolationWrap( bool bWrap )
|
|
{
|
|
m_bInterpolationWrap = bWrap;
|
|
}
|
|
|
|
void CPoseController::SetCycleFrequency( float fValue )
|
|
{
|
|
m_fCycleFrequency = clamp( fValue, -MAX_POSE_CYCLE_FREQUENCY, MAX_POSE_CYCLE_FREQUENCY );
|
|
}
|
|
|
|
void CPoseController::SetFModType( int nType )
|
|
{
|
|
if ( nType < 0 || nType >= POSECONTROLLER_FMODTYPE_TOTAL )
|
|
return;
|
|
|
|
m_nFModType = static_cast<PoseController_FModType_t>(nType);
|
|
}
|
|
|
|
void CPoseController::SetFModTimeOffset( float fValue )
|
|
{
|
|
m_fFModTimeOffset = clamp( fValue, -1.0f, 1.0f );
|
|
}
|
|
|
|
void CPoseController::SetFModRate( float fValue )
|
|
{
|
|
m_fFModRate = clamp( fValue, -MAX_POSE_FMOD_RATE, MAX_POSE_FMOD_RATE );
|
|
}
|
|
|
|
void CPoseController::SetFModAmplitude( float fValue )
|
|
{
|
|
m_fFModAmplitude = clamp( fValue, 0.0f, MAX_POSE_FMOD_AMPLITUDE );
|
|
}
|
|
|
|
void CPoseController::RandomizeFMod( float fExtremeness )
|
|
{
|
|
fExtremeness = clamp( fExtremeness, 0.0f, 1.0f );
|
|
|
|
SetFModType( RandomInt( 1, POSECONTROLLER_FMODTYPE_TOTAL - 1 ) );
|
|
SetFModTimeOffset( RandomFloat( -1.0, 1.0f ) );
|
|
SetFModRate( RandomFloat( fExtremeness * -MAX_POSE_FMOD_RATE, fExtremeness * MAX_POSE_FMOD_RATE ) );
|
|
SetFModAmplitude( RandomFloat( 0.0f, fExtremeness * MAX_POSE_FMOD_AMPLITUDE ) );
|
|
}
|
|
|
|
void CPoseController::InputSetPoseParameterName( inputdata_t &inputdata )
|
|
{
|
|
SetPoseParameterName( inputdata.value.String() );
|
|
}
|
|
|
|
void CPoseController::InputSetPoseValue( inputdata_t &inputdata )
|
|
{
|
|
SetPoseValue( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputSetInterpolationTime( inputdata_t &inputdata )
|
|
{
|
|
SetInterpolationTime( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputSetCycleFrequency( inputdata_t &inputdata )
|
|
{
|
|
SetCycleFrequency( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputSetFModType( inputdata_t &inputdata )
|
|
{
|
|
SetFModType( inputdata.value.Int() );
|
|
}
|
|
|
|
void CPoseController::InputSetFModTimeOffset( inputdata_t &inputdata )
|
|
{
|
|
SetFModTimeOffset( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputSetFModRate( inputdata_t &inputdata )
|
|
{
|
|
SetFModRate( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputSetFModAmplitude( inputdata_t &inputdata )
|
|
{
|
|
SetFModAmplitude( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputRandomizeFMod( inputdata_t &inputdata )
|
|
{
|
|
RandomizeFMod( inputdata.value.Float() );
|
|
}
|
|
|
|
void CPoseController::InputGetFMod( inputdata_t &inputdata )
|
|
{
|
|
DevMsg( "FMod values for pose controller %s\nTYPE: %i\nTIME OFFSET: %f\nRATE: %f\nAMPLITUDE: %f\n",
|
|
STRING( GetEntityName() ),
|
|
m_nFModType.Get(),
|
|
m_fFModTimeOffset.Get(),
|
|
m_fFModRate.Get(),
|
|
m_fFModAmplitude.Get() );
|
|
}
|
|
|
|
|
|
#else //#ifndef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// CLIENT CLASS
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
IMPLEMENT_CLIENTCLASS_DT( C_PoseController, DT_PoseController, CPoseController )
|
|
RecvPropArray3( RECVINFO_ARRAY(m_hProps), RecvPropEHandle( RECVINFO(m_hProps[0]) ) ),
|
|
RecvPropArray3( RECVINFO_ARRAY(m_chPoseIndex), RecvPropInt( RECVINFO(m_chPoseIndex[0]) ) ),
|
|
RecvPropBool( RECVINFO(m_bPoseValueParity) ),
|
|
RecvPropFloat( RECVINFO(m_fPoseValue) ),
|
|
RecvPropFloat( RECVINFO(m_fInterpolationTime) ),
|
|
RecvPropBool( RECVINFO(m_bInterpolationWrap) ),
|
|
RecvPropFloat( RECVINFO(m_fCycleFrequency) ),
|
|
RecvPropInt( RECVINFO(m_nFModType) ),
|
|
RecvPropFloat( RECVINFO(m_fFModTimeOffset) ),
|
|
RecvPropFloat( RECVINFO(m_fFModRate) ),
|
|
RecvPropFloat( RECVINFO(m_fFModAmplitude) ),
|
|
END_RECV_TABLE()
|
|
|
|
|
|
void C_PoseController::Spawn( void )
|
|
{
|
|
SetThink( &C_PoseController::ClientThink );
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
|
|
m_fCurrentFMod = 0.0f;
|
|
m_PoseTransitionValue.Init( 0.0f, 0.0f, 0.0f );
|
|
|
|
BaseClass::Spawn();
|
|
}
|
|
|
|
void C_PoseController::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
// Start thinking (Baseclass stops it)
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
|
|
m_bOldPoseValueParity = m_bPoseValueParity;
|
|
m_fCurrentPoseValue = m_fPoseValue;
|
|
|
|
SetCurrentPose( m_fCurrentPoseValue );
|
|
}
|
|
|
|
if ( m_bOldPoseValueParity != m_bPoseValueParity )
|
|
{
|
|
// If the pose value was set directly set the actual pose value
|
|
float fClientPoseValue = m_fCurrentPoseValue + m_PoseTransitionValue.Interp( gpGlobals->curtime );
|
|
|
|
if ( fClientPoseValue < 0.0f )
|
|
fClientPoseValue += 1.0f;
|
|
else if ( fClientPoseValue > 1.0f )
|
|
fClientPoseValue -= 1.0f;
|
|
|
|
float fInterpForward = fClientPoseValue - m_fPoseValue;
|
|
|
|
if ( m_bInterpolationWrap )
|
|
{
|
|
float fInterpBackward = ( fClientPoseValue + ( ( fClientPoseValue < 0.5f ) ? ( 1.0f ) : ( -1.0f ) ) ) - m_fPoseValue;
|
|
|
|
m_PoseTransitionValue.Init( ( ( fabsf( fInterpForward ) < fabsf( fInterpBackward ) ) ? ( fInterpForward ) : ( fInterpBackward ) ), 0.0f, m_fInterpolationTime );
|
|
}
|
|
else
|
|
{
|
|
m_PoseTransitionValue.Init( fInterpForward, 0.0f, m_fInterpolationTime );
|
|
}
|
|
|
|
m_bOldPoseValueParity = m_bPoseValueParity;
|
|
m_fCurrentPoseValue = m_fPoseValue;
|
|
}
|
|
}
|
|
|
|
void C_PoseController::ClientThink( void )
|
|
{
|
|
UpdateModulation();
|
|
|
|
UpdatePoseCycle( m_fCycleFrequency + m_fCurrentFMod );
|
|
}
|
|
|
|
void C_PoseController::UpdateModulation( void )
|
|
{
|
|
switch ( m_nFModType )
|
|
{
|
|
case POSECONTROLLER_FMODTYPE_NONE:
|
|
{
|
|
// No modulation
|
|
m_fCurrentFMod = 0.0f;
|
|
break;
|
|
}
|
|
|
|
case POSECONTROLLER_FMODTYPE_SINE:
|
|
{
|
|
float fCycleTime = m_fFModRate * ( gpGlobals->curtime + m_fFModTimeOffset );
|
|
|
|
m_fCurrentFMod = m_fFModAmplitude * sinf( fCycleTime * ( 2.0f * M_PI ) );
|
|
break;
|
|
}
|
|
|
|
case POSECONTROLLER_FMODTYPE_SQUARE:
|
|
{
|
|
float fCycleTime = fabsf( m_fFModRate * 2.0f * ( gpGlobals->curtime + m_fFModTimeOffset ) );
|
|
|
|
// Separate the current time into integer and decimal
|
|
int iIntegerPortion = static_cast<int>( fCycleTime );
|
|
|
|
// Find if it's going up or down
|
|
if ( ( iIntegerPortion % 2 ) == 0 )
|
|
m_fCurrentFMod = m_fFModAmplitude;
|
|
else
|
|
m_fCurrentFMod = -m_fFModAmplitude;
|
|
|
|
break;
|
|
}
|
|
|
|
case POSECONTROLLER_FMODTYPE_TRIANGLE:
|
|
{
|
|
float fCycleTime = fabsf( m_fFModRate * 4.0f * ( gpGlobals->curtime + m_fFModTimeOffset ) );
|
|
|
|
// Separate the current time into integer and decimal
|
|
int iIntegerPortion = static_cast<int>( fCycleTime );
|
|
float fDecimalPortion = fCycleTime - static_cast<float>( iIntegerPortion );
|
|
|
|
// Find if it's going up from 0, down from 1, down from 0, or up from -1
|
|
switch ( iIntegerPortion % 4 )
|
|
{
|
|
case 0:
|
|
m_fCurrentFMod = fDecimalPortion * m_fFModAmplitude;
|
|
break;
|
|
case 1:
|
|
m_fCurrentFMod = ( 1.0f - fDecimalPortion ) * m_fFModAmplitude;
|
|
break;
|
|
case 2:
|
|
m_fCurrentFMod = -fDecimalPortion * m_fFModAmplitude;
|
|
break;
|
|
case 3:
|
|
m_fCurrentFMod = ( -1.0f + fDecimalPortion ) * m_fFModAmplitude;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case POSECONTROLLER_FMODTYPE_SAWTOOTH:
|
|
{
|
|
float fCycleTime = fabsf( m_fFModRate * 2.0f * ( gpGlobals->curtime + m_fFModTimeOffset ) );
|
|
|
|
// Separate the current time into integer and decimal
|
|
int iIntegerPortion = static_cast<int>( fCycleTime );
|
|
float fDecimalPortion = fCycleTime - static_cast<float>( iIntegerPortion );
|
|
|
|
// Find if it's going up from 0 or up from -1
|
|
if ( ( iIntegerPortion % 2 ) == 0 )
|
|
m_fCurrentFMod = fDecimalPortion * m_fFModAmplitude;
|
|
else
|
|
m_fCurrentFMod = ( -1.0f + fDecimalPortion ) * m_fFModAmplitude;
|
|
|
|
break;
|
|
}
|
|
|
|
case POSECONTROLLER_FMODTYPE_NOISE:
|
|
{
|
|
// Randomly increase or decrease by the rate
|
|
if ( RandomInt( 0, 1 ) == 0 )
|
|
m_fCurrentFMod += m_fFModRate * gpGlobals->frametime;
|
|
else
|
|
m_fCurrentFMod -= m_fFModRate * gpGlobals->frametime;
|
|
|
|
m_fCurrentFMod = clamp( m_fCurrentFMod, -m_fFModAmplitude, m_fFModAmplitude );
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void C_PoseController::UpdatePoseCycle( float fCycleAmount )
|
|
{
|
|
m_fCurrentPoseValue += fCycleAmount * gpGlobals->frametime;
|
|
|
|
float fNewPoseValue = m_fCurrentPoseValue + m_PoseTransitionValue.Interp( gpGlobals->curtime );
|
|
|
|
if ( fNewPoseValue < 0.0f )
|
|
fNewPoseValue += 1.0f;
|
|
else if ( fNewPoseValue > 1.0f )
|
|
fNewPoseValue -= 1.0f;
|
|
|
|
SetCurrentPose( fNewPoseValue );
|
|
}
|
|
|
|
#define CPoseController C_PoseController
|
|
#define CBaseAnimating C_BaseAnimating
|
|
|
|
|
|
#endif //#ifndef CLIENT_DLL
|
|
|
|
|
|
void CPoseController::SetCurrentPose( float fCurrentPoseValue )
|
|
{
|
|
for ( int iPropNum = 0; iPropNum < MAX_POSE_CONTROLLED_PROPS; ++iPropNum )
|
|
{
|
|
// Control each model's pose parameter
|
|
CBaseAnimating *pProp = dynamic_cast<CBaseAnimating*>( m_hProps[ iPropNum ].Get() );
|
|
|
|
if ( pProp )
|
|
{
|
|
float fPoseValueMin;
|
|
float fPoseValueMax;
|
|
|
|
// Map to the pose parameter's range
|
|
pProp->GetPoseParameterRange( m_chPoseIndex[ iPropNum ], fPoseValueMin, fPoseValueMax );
|
|
pProp->SetPoseParameter( m_chPoseIndex[ iPropNum ], fPoseValueMin + fCurrentPoseValue * ( fPoseValueMax - fPoseValueMin ) );
|
|
}
|
|
}
|
|
}
|