void CGaussianNoiseProxy::OnBind( void *pC_BaseEntity )
{
float flMean = m_Mean.GetFloat();
float flStdDev = m_StdDev.GetFloat();
float flVal = randomgaussian->RandomFloat( flMean, flStdDev );
float flMaxVal = m_flMaxVal.GetFloat();
float flMinVal = m_flMinVal.GetFloat();
if (flMinVal > flMaxVal)
{
float flTemp = flMinVal;
flMinVal = flMaxVal;
flMaxVal = flTemp;
}
// clamp
if (flVal < flMinVal)
flVal = flMinVal;
else if ( flVal > flMaxVal )
flVal = flMaxVal;
SetFloatResult( flVal );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
void CExponentialProxy::OnBind( void *pC_BaseEntity )
{
float flVal = m_Scale.GetFloat() * exp(m_pSrc1->GetFloatValue( ) + m_Offset.GetFloat());
float flMaxVal = m_flMaxVal.GetFloat();
float flMinVal = m_flMinVal.GetFloat();
if (flMinVal > flMaxVal)
{
float flTemp = flMinVal;
flMinVal = flMaxVal;
flMaxVal = flTemp;
}
// clamp
if (flVal < flMinVal)
flVal = flMinVal;
else if ( flVal > flMaxVal )
flVal = flMaxVal;
SetFloatResult( flVal );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
bool CPupilProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
char const* pAnimatedTextureVarName = pKeyValues->GetString( "TextureVar" );
if( !pAnimatedTextureVarName )
return false;
bool foundVar;
m_pAnimatedTextureVar = pMaterial->FindVar( pAnimatedTextureVarName, &foundVar, false );
if( !foundVar )
return false;
char const* pAnimatedTextureFrameNumVarName = pKeyValues->GetString( "TextureFrameNumVar" );
if( !pAnimatedTextureFrameNumVarName )
return false;
m_pAnimatedTextureFrameNumVar = pMaterial->FindVar( pAnimatedTextureFrameNumVarName, &foundVar, false );
if( !foundVar )
return false;
m_pLightingVar = pMaterial->FindVar( "$lighting", &foundVar, false );
if( !foundVar )
{
Warning("Materials using the pupil proxy must have a field called $lighting which has a value of 0.5!\n" );
return false;
}
m_flPupilCloseRate.Init( pMaterial, pKeyValues, "PupilCloseRate", DEFAULT_CLOSE_PUPIL_RATE );
m_flPupilOpenRate.Init( pMaterial, pKeyValues, "PupilOpenRate", DEFAULT_OPEN_PUPIL_RATE );
return true;
}
void CClampProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pSrc1 && m_pResult );
MaterialVarType_t resultType;
int vecSize;
ComputeResultType( resultType, vecSize );
float flMin = m_Min.GetFloat();
float flMax = m_Max.GetFloat();
if (flMin > flMax)
{
float flTemp = flMin;
flMin = flMax;
flMax = flTemp;
}
switch( resultType )
{
case MATERIAL_VAR_TYPE_VECTOR:
{
Vector a;
m_pSrc1->GetVecValue( a.Base(), vecSize );
for (int i = 0; i < vecSize; ++i)
{
if (a[i] < flMin)
a[i] = flMin;
else if (a[i] > flMax)
a[i] = flMax;
}
m_pResult->SetVecValue( a.Base(), vecSize );
}
break;
case MATERIAL_VAR_TYPE_FLOAT:
{
float src = m_pSrc1->GetFloatValue();
if (src < flMin)
src = flMin;
else if (src > flMax)
src = flMax;
SetFloatResult( src );
}
break;
case MATERIAL_VAR_TYPE_INT:
{
int src = m_pSrc1->GetIntValue();
if (src < flMin)
src = flMin;
else if (src > flMax)
src = flMax;
m_pResult->SetIntValue( src );
}
break;
}
}
void CUniformNoiseProxy::OnBind( void *pC_BaseEntity )
{
SetFloatResult( random->RandomFloat( m_flMinVal.GetFloat(), m_flMaxVal.GetFloat() ) );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
void CLinearRampProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pResult );
float flValue;
// get a value in [0,1]
flValue = m_Rate.GetFloat() * gpGlobals->curtime + m_InitialValue.GetFloat();
SetFloatResult( flValue );
}
bool CWrapMinMaxProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CFunctionProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_flMinVal.Init( pMaterial, pKeyValues, "minVal", 0 ))
return false;
if (!m_flMaxVal.Init( pMaterial, pKeyValues, "maxVal", 1 ))
return false;
return true;
}
bool CLinearRampProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Rate.Init( pMaterial, pKeyValues, "rate", 1 ))
return false;
if (!m_InitialValue.Init( pMaterial, pKeyValues, "initialValue", 0 ))
return false;
return true;
}
bool CUniformNoiseProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_flMinVal.Init( pMaterial, pKeyValues, "minVal", 0 ))
return false;
if (!m_flMaxVal.Init( pMaterial, pKeyValues, "maxVal", 1 ))
return false;
return true;
}
bool CClampProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CFunctionProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Min.Init( pMaterial, pKeyValues, "min", 0 ))
return false;
if (!m_Max.Init( pMaterial, pKeyValues, "max", 1 ))
return false;
return true;
}
void CTextureScrollMaterialProxy::OnBind( void *pC_BaseEntity )
{
if( !m_pTextureScrollVar )
{
return;
}
float rate, angle, scale;
// set default values if these variables don't exist.
rate = m_TextureScrollRate.GetFloat();
angle = m_TextureScrollAngle.GetFloat();
scale = m_TextureScale.GetFloat();
float sOffset, tOffset;
sOffset = gpGlobals->curtime * cos( angle * ( M_PI / 180.0f ) ) * rate;
tOffset = gpGlobals->curtime * sin( angle * ( M_PI / 180.0f ) ) * rate;
// make sure that we are positive
if( sOffset < 0.0f )
{
sOffset += 1.0f + -( int )sOffset;
}
if( tOffset < 0.0f )
{
tOffset += 1.0f + -( int )tOffset;
}
// make sure that we are in a [0,1] range
sOffset = sOffset - ( int )sOffset;
tOffset = tOffset - ( int )tOffset;
if (m_pTextureScrollVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)
{
VMatrix mat( scale, 0.0f, 0.0f, sOffset,
0.0f, scale, 0.0f, tOffset,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f );
m_pTextureScrollVar->SetMatrixValue( mat );
}
else
{
m_pTextureScrollVar->SetVecValue( sOffset, tOffset, 0.0f );
}
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
void CWrapMinMaxProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pSrc1 && m_pResult );
if ( m_flMaxVal.GetFloat() <= m_flMinVal.GetFloat() ) // Bad input, just return the MIN
{
SetFloatResult( m_flMinVal.GetFloat() );
}
else
{
float flResult = ( m_pSrc1->GetFloatValue() - m_flMinVal.GetFloat() ) / ( m_flMaxVal.GetFloat() - m_flMinVal.GetFloat() );
if ( flResult >= 0.0f )
{
flResult -= ( float )( int )flResult;
}
else // Negative
{
flResult -= ( float )( ( ( int )flResult ) - 1 );
}
flResult *= ( m_flMaxVal.GetFloat() - m_flMinVal.GetFloat() );
flResult += m_flMinVal.GetFloat();
SetFloatResult( flResult );
}
}
void CWrapMinMaxProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pSrc1 && m_pResult );
if ( m_flMaxVal.GetFloat() <= m_flMinVal.GetFloat() ) // Bad input, just return the min
{
SetFloatResult( m_flMinVal.GetFloat() );
}
else
{
float flResult = ( m_pSrc1->GetFloatValue() - m_flMinVal.GetFloat() ) / ( m_flMaxVal.GetFloat() - m_flMinVal.GetFloat() );
if ( flResult >= 0.0f )
{
flResult -= ( float )( int )flResult;
}
else // Negative
{
flResult -= ( float )( ( ( int )flResult ) - 1 );
}
flResult *= ( m_flMaxVal.GetFloat() - m_flMinVal.GetFloat() );
flResult += m_flMinVal.GetFloat();
SetFloatResult( flResult );
}
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
void CLinearRampProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pResult );
float flValue;
// get a value in [0,1]
flValue = m_Rate.GetFloat() * gpGlobals->curtime + m_InitialValue.GetFloat();
SetFloatResult( flValue );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
void CPlayerDamageTimeProxy::OnBind( void *pArg )
{
C_BaseEntity *pEntity = BindArgToEntity( pArg );
// NOTE: Player health max is not available on the server...
C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEntity);
if (!pPlayer)
{
SetFloatResult( 10000 * m_Factor.GetFloat() );
return;
}
Assert( m_pResult );
float dt = gpGlobals->curtime - pPlayer->GetLastDamageTime();
SetFloatResult( dt * m_Factor.GetFloat() );
}
void CPlayerHealthProxy::OnBind( void *pArg )
{
// NOTE: Player health max is not available on the server...
C_BaseEntity *pEntity = BindArgToEntity( pArg );
C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEntity);
if (!pPlayer)
return;
Assert( m_pResult );
SetFloatResult( pPlayer->HealthFraction() * m_Factor.GetFloat() );
/*
// Should we draw their health?
// If he's not on our team we can't see it unless we're a command with "targetinginfo".
if ( GetLocalTeam() != GetTeam() && !(local->HasNamedTechnology("targetinginfo") && IsLocalPlayerClass(TFCLASS_COMMANDO) ))
return drawn;
// Don't draw health bars above myself
if ( local == this )
return drawn;
// Don't draw health bars over dead/dying player
if ( GetHealth() <= 0 )
return drawn;
return drawn;
*/
}
bool CSineProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_SinePeriod.Init( pMaterial, pKeyValues, "sinePeriod", 1.0f ))
return false;
if (!m_SineMax.Init( pMaterial, pKeyValues, "sineMax", 1.0f ))
return false;
if (!m_SineMin.Init( pMaterial, pKeyValues, "sineMin", 0.0f ))
return false;
if (!m_SineTimeOffset.Init( pMaterial, pKeyValues, "timeOffset", 0.0f ))
return false;
return true;
}
void CPupilProxy::OnBind( C_BaseEntity *pBaseEntity )
{
if (!pBaseEntity || !m_pAnimatedTextureVar )
return;
if( m_pAnimatedTextureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
return;
ITexture *pTexture = m_pAnimatedTextureVar->GetTextureValue();
int nFrameCount = pTexture->GetNumAnimationFrames();
// Compute the lighting at the eye position of the entity; use it to dialate the pupil
Vector forward;
pBaseEntity->GetVectors( &forward, NULL, NULL );
Vector eyePt = pBaseEntity->EyePosition();
Vector color;
engine->ComputeLighting( eyePt, &forward, false, color );
// Compute the intensity...
float flIntensity = ( 0.299f * color[0] + 0.587f * color[1] + 0.114f * color[2] ) * 0.5;
flIntensity = clamp( flIntensity, 0, 1 );
float flLastIntensity = m_pLightingVar->GetFloatValue( );
if ( flIntensity > flLastIntensity )
{
float flMaxChange = m_flPupilCloseRate.GetFloat() * gpGlobals->frametime;
if ( flIntensity > (flMaxChange + flLastIntensity) )
{
flIntensity = flLastIntensity + flMaxChange;
}
}
else
{
float flMaxChange = m_flPupilOpenRate.GetFloat() * gpGlobals->frametime;
if ( flIntensity < (flLastIntensity - flMaxChange) )
{
flIntensity = flLastIntensity - flMaxChange;
}
}
int nFrame = nFrameCount * flIntensity;
nFrame = clamp( nFrame, 0, nFrameCount - 1 );
m_pAnimatedTextureFrameNumVar->SetIntValue( nFrame );
m_pLightingVar->SetFloatValue( flIntensity );
}
bool CTextureScrollMaterialProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
char const* pScrollVarName = pKeyValues->GetString( "textureScrollVar" );
if( !pScrollVarName )
return false;
bool foundVar;
m_pTextureScrollVar = pMaterial->FindVar( pScrollVarName, &foundVar, false );
if( !foundVar )
return false;
m_TextureScrollRate.Init( pMaterial, pKeyValues, "textureScrollRate", 1.0f );
m_TextureScrollAngle.Init( pMaterial, pKeyValues, "textureScrollAngle", 0.0f );
m_TextureScale.Init( pMaterial, pKeyValues, "textureScale", 1.0f );
return true;
}
bool CEntityRandomProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ))
return false;
return true;
}
bool CPlayerFortsTimerProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_RangeMax.Init( pMaterial, pKeyValues, "rangeMax", 360 ))
return false;
return true;
}
bool CPlayerDamageTimeProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1.0f ))
return false;
return true;
}
bool CObjectPowerProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ))
return false;
return true;
}
void CSineProxy::OnBind( void *pC_BaseEntity )
{
Assert( m_pResult );
float flValue;
float flSineTimeOffset = m_SineTimeOffset.GetFloat();
float flSineMax = m_SineMax.GetFloat();
float flSineMin = m_SineMin.GetFloat();
float flSinePeriod = m_SinePeriod.GetFloat();
if (flSinePeriod == 0)
flSinePeriod = 1;
// get a value in [0,1]
flValue = ( sin( 2.0f * M_PI * (gpGlobals->curtime - flSineTimeOffset) / flSinePeriod ) * 0.5f ) + 0.5f;
// get a value in [MIN,MAX]
flValue = ( flSineMax - flSineMin ) * flValue + flSineMin;
SetFloatResult( flValue );
}
void CProxyHealth::OnBind( void *pC_BaseEntity )
{
if (!pC_BaseEntity)
return;
C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
Assert( m_pResult );
SetFloatResult( pEntity->HealthFraction() * m_Factor.GetFloat() );
}
bool CExponentialProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CFunctionProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Scale.Init( pMaterial, pKeyValues, "scale", 1.0f ))
return false;
if (!m_Offset.Init( pMaterial, pKeyValues, "offset", 0.0f ))
return false;
if (!m_flMinVal.Init( pMaterial, pKeyValues, "minVal", -FLT_MAX ))
return false;
if (!m_flMaxVal.Init( pMaterial, pKeyValues, "maxVal", FLT_MAX ))
return false;
return true;
}
bool CGaussianNoiseProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
if (!CResultProxy::Init( pMaterial, pKeyValues ))
return false;
if (!m_Mean.Init( pMaterial, pKeyValues, "mean", 0.0f ))
return false;
if (!m_StdDev.Init( pMaterial, pKeyValues, "halfwidth", 1.0f ))
return false;
if (!m_flMinVal.Init( pMaterial, pKeyValues, "minVal", -FLT_MAX ))
return false;
if (!m_flMaxVal.Init( pMaterial, pKeyValues, "maxVal", FLT_MAX ))
return false;
return true;
}
void CExponentialProxy::OnBind( void *pC_BaseEntity )
{
float flVal = m_Scale.GetFloat() * exp(m_pSrc1->GetFloatValue( ) + m_Offset.GetFloat());
float flMaxVal = m_flMaxVal.GetFloat();
float flMinVal = m_flMinVal.GetFloat();
if (flMinVal > flMaxVal)
{
float flTemp = flMinVal;
flMinVal = flMaxVal;
flMaxVal = flTemp;
}
// clamp
if (flVal < flMinVal)
flVal = flMinVal;
else if ( flVal > flMaxVal )
flVal = flMaxVal;
SetFloatResult( flVal );
}
void CGaussianNoiseProxy::OnBind( void *pC_BaseEntity )
{
float flMean = m_Mean.GetFloat();
float flStdDev = m_StdDev.GetFloat();
float flVal = randomgaussian->RandomFloat( flMean, flStdDev );
float flMaxVal = m_flMaxVal.GetFloat();
float flMinVal = m_flMinVal.GetFloat();
if (flMinVal > flMaxVal)
{
float flTemp = flMinVal;
flMinVal = flMaxVal;
flMaxVal = flTemp;
}
// clamp
if (flVal < flMinVal)
flVal = flMinVal;
else if ( flVal > flMaxVal )
flVal = flMaxVal;
SetFloatResult( flVal );
}
void CPlayerFortsTimerProxy::OnBind( void *pC_BaseEntity )
{
if(HL2MPRules()->GetGameType() != GAME_FORTS)
return;
float flPhaseLimit = HL2MPRules()->GetLastFortsPhaseTime();
flPhaseLimit += HL2MPRules()->IsFortsBuildPhase() ? mp_forts_buildtime.GetFloat() * 60 : mp_forts_fighttime.GetFloat() * 60;
// Produit en croix
// ? | curtime
// 360 | phaselimit
SetFloatResult( ceil( gpGlobals->curtime * m_RangeMax.GetFloat() / flPhaseLimit ));
}
