void Bench_CheckEntity( int type, struct cl_entity_s *ent, const char *modelname )
{
if ( Bench_InStage( THIRD_STAGE ) && !stricmp( modelname, "*3" ) )
{
model_t *pmod;
vec3_t v;
pmod = (model_t *)( ent->model );
VectorAdd( pmod->mins, pmod->maxs, v );
VectorScale( v, 0.5, v );
VectorAdd( v, ent->origin, g_aimorg );
}
if ( Bench_InStage( THIRD_STAGE ) && strstr( modelname, "ppdemodot" ) )
{
Bench_SetDotAdded( 1 );
VectorCopy( ent->origin, g_dotorg );
// Adjust end position
if ( Bench_Active() && Bench_InStage( THIRD_STAGE ) )
{
static float fZAdjust = 0.0;
static float fLastTime;
float dt;
float fRate = Bench_GetPowerPlay() ? 4.0 : 8.0;
float fBounds = Bench_GetPowerPlay() ? 8.0 : 15.0;
dt = gHUD.m_flTime - fLastTime;
if ( dt > 0.0 && dt < 1.0 )
{
fZAdjust += gEngfuncs.pfnRandomFloat( -fRate, fRate );
fZAdjust = min( fBounds, fZAdjust );
fZAdjust = max( -fBounds, fZAdjust );
ent->origin[2] += fZAdjust;
g_fZAdjust = fZAdjust;
}
fLastTime = gHUD.m_flTime;
}
}
}
void Bench_CheckEntity( int type, cl_entity_t *ent, const char *modelname )
{
if ( Bench_InStage( THIRD_STAGE ) && !stricmp( modelname, "*3" ) )
{
model_t *pmod = ent->model;
const Vector v = ( pmod->mins + pmod->maxs ) * 0.5;
g_aimorg = v + ent->origin;
}
if ( Bench_InStage( THIRD_STAGE ) && strstr( modelname, "ppdemodot" ) )
{
Bench_SetDotAdded( 1 );
g_dotorg = ent->origin;
// Adjust end position
if ( Bench_Active() && Bench_InStage( THIRD_STAGE ) )
{
static float fZAdjust = 0.0;
static float fLastTime;
float dt;
float fRate = Bench_GetPowerPlay() ? 4.0 : 8.0;
float fBounds = Bench_GetPowerPlay() ? 8.0 : 15.0;
dt = gHUD.m_flTime - fLastTime;
if ( dt > 0.0 && dt < 1.0 )
{
fZAdjust += gEngfuncs.pfnRandomFloat( -fRate, fRate );
fZAdjust = min( fBounds, fZAdjust );
fZAdjust = max( -fBounds, fZAdjust );
ent->origin[2] += fZAdjust;
g_fZAdjust = fZAdjust;
}
fLastTime = gHUD.m_flTime;
}
}
}
int CHudBenchmark::Bench_ScoreForValue( int stage, float raw )
{
int score = 100.0;
int power_play = Bench_GetPowerPlay() ? 1 : 0;
switch ( stage )
{
case FIRST_STAGE: // ping
score = 100.0 * ( m_StoredLatency );
score = max( score, 0 );
score = min( score, 100 );
// score is inverted
score = 100 - score;
break;
case SECOND_STAGE: // framerate/performance
score = (int)( 100 * m_fAvgFrameRate ) / 72;
score = min( score, 100 );
score = max( score, 0 );
score *= BENCH_RANGE/100.0;
if ( power_play )
{
score += ( 100 - BENCH_RANGE );
}
break;
case THIRD_STAGE: // tracking
score = (100 * m_fAvgScore) / 40;
score = max( score, 0 );
score = min( score, 100 );
// score is inverted
score = 100 - score;
score *= BENCH_RANGE/100.0;
if ( power_play )
{
score += ( 100 - BENCH_RANGE );
}
break;
//TODO: missing fourth stage?
}
return score;
}
//TODO: this looks an awful lot like the function above. Consider refactoring - Solokiller
void HUD_CreateBenchObjects( const Vector& origin )
{
static cl_entity_t bench[ NUM_BENCH_OBJ ];
cl_entity_t *player;
Vector forward, right, up;
Vector farpoint;
Vector centerspot;
static int first = true;
static int failed = false;
static float last_time;
float frametime;
float frac;
float frac2;
float dt;
pmtrace_t tr;
int i = 0;
if ( gHUD.m_flTime == last_time )
return;
frametime = gHUD.m_flTime - last_time;
last_time = gHUD.m_flTime;
if ( frametime <= 0.0 )
return;
if ( failed )
return;
player = gEngfuncs.GetLocalPlayer();
if ( !player )
{
failed = true;
return;
}
if ( first )
{
first = false;
if ( !HUD_SetupBenchObjects( bench, player->index - 1, origin ) )
{
failed = true;
return;
}
}
gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
// Store off the old count
gEngfuncs.pEventAPI->EV_PushPMStates();
// Now add in all of the players.
gEngfuncs.pEventAPI->EV_SetSolidPlayers ( player->index - 1 );
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
dt = gHUD.m_flTime - g_flStartTime;
if ( dt < 0 )
return;
frac = dt / BENCH_CYCLE_TIME;
if ( frac > 1.0 )
{
frac = frac - (float)(int)frac;
}
frac2 = dt /BENCH_INNER_CYCLE_TIME;
if ( frac2 > 1.0 )
{
frac2 = frac2 - (float)(int)frac2;
}
// Determine forward vector
AngleVectors ( vec3_origin, forward, right, up );
centerspot = origin;
centerspot[2] -= 512;
gEngfuncs.pEventAPI->EV_PlayerTrace( origin, centerspot, PM_NORMAL, -1, &tr );
centerspot = tr.endpos;
centerspot[2] += BENCH_BALLHEIGHT;
// Move center out from here
centerspot = centerspot + BENCH_VIEW_OFFSET * forward;
for ( i = 0; i < NUM_BENCH_OBJ; i++ )
{
int j;
float jitter = 0.0;
float jfrac;
float offset;
float ofs_radius = 5.0;
Vector ang;
offset = ( float ) i / (float) ( NUM_BENCH_OBJ - 1 );
ang[ 0 ] = 0;
ang[ 2 ] = 0;
ang[ 1 ] = BENCH_SWEEP * offset + frac * 360.0;
// normalize
ang = ang.Normalize();
// Determine forward vector
AngleVectors ( ang, forward, right, up );
// Get a far point for ray trace
farpoint = centerspot + ( BENCH_RADIUS + ofs_radius * sin( BENCH_SWEEP * offset + frac2 * 2 * M_PI ) ) * forward;
farpoint[2] += 10 * cos( BENCH_SWEEP * offset + frac2 * 2 * M_PI );
gEngfuncs.pEventAPI->EV_PlayerTrace( centerspot, farpoint, PM_NORMAL, -1, &tr );
// Add angular velocity
VectorMA( bench[ i ].curstate.angles, frametime, bench[ i ].baseline.angles, bench[ i ].curstate.angles );
bench[ i ].curstate.angles = bench[ i ].curstate.angles.Normalize();
jfrac = ( (float)gHUD.m_Benchmark.GetObjects() / (float)NUM_BENCH_OBJ );
// Adjust velocity
//bench[ i ].curstate.velocity[ 2 ] -= bench[ i ].curstate.gravity * frametime * 800;
/*
// Did we hit something?
if ( tr.fraction != 1.0 && !tr.inwater )
{
float damp;
float proj;
Vector traceNormal;
int j;
traceNormal = tr.plane.normal;
damp = 0.9;
// Reflect velocity
if ( damp != 0 )
{
proj = DotProduct( bench[ i ].curstate.velocity, traceNormal );
VectorMA( bench[ i ].curstate.velocity, -proj*2, traceNormal, bench[ i ].curstate.velocity );
// Reflect rotation (fake)
for ( j = 0 ; j < 3; j++ )
{
if ( bench[ i ].curstate.velocity[ j ] > 1000.0 )
{
bench[ i ].curstate.velocity[ j ] = 1000.0;
}
else if ( bench[ i ].curstate.velocity[ j ] < -1000.0 )
{
bench[ i ].curstate.velocity[ j ] = -1000.0;
}
}
bench[ i ].baseline.angles[1] = -bench[ i ].baseline.angles[1];
bench[ i ].curstate.velocity = bench[ i ].curstate.velocity * damp;
}
}
*/
if ( i == ( NUM_BENCH_OBJ - 1 ) )
{
g_aimorg = tr.endpos;
}
if ( Bench_GetPowerPlay() )
{
jitter = 0.5;
}
else
{
jitter = 8.0;
}
jitter *= jfrac;
for ( j = 0; j < 2; j++ )
{
tr.endpos[ j ] += gEngfuncs.pfnRandomFloat( -jitter, jitter );
}
// Add to visedicts list for rendering
// Move dot to trace endpoint
bench[ i ].origin = tr.endpos;
bench[ i ].curstate.origin = bench[ i ].origin;
bench[ i ].angles = bench[ i ].curstate.angles;
// Force no interpolation, etc., probably not necessary
bench[ i ].prevstate = bench[ i ].curstate;
if ( ( NUM_BENCH_OBJ - i - 1 ) < gHUD.m_Benchmark.GetObjects() )
{
if ( bench[ i ].curstate.renderamt == 255 )
{
bench[i].curstate.rendermode = kRenderNormal;
}
else
{
bench[i].curstate.renderamt += BLEND_IN_SPEED * frametime;
bench[i].curstate.renderamt = min( 255, bench[i].curstate.renderamt );
bench[i].curstate.rendermode = kRenderTransAlpha;
}
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, &bench[ i ] );
}
}
gEngfuncs.pEventAPI->EV_PopPMStates();
}
bool CHudBenchmark::Draw( float flTime )
{
char sz[ 256 ];
int x, y;
if ( m_fDrawTime < flTime || !Bench_Active() )
{
m_iFlags &= ~HUD_ACTIVE;
return true;
}
x = 10;
y = 25; //480 - 150;
sprintf( sz, "%s: %s", g_title , pp_strings[ Bench_GetPowerPlay() ? 0 : 1]);
gHUD.DrawHudString( x, y, 320, sz, 251, 237, 7);// , 200, 200); //255, 255, 255 );
y += 20;
// sprintf( sz, pp_strings[ Bench_GetPowerPlay() ? 0 : 1 ] );
// gHUD.DrawHudString( x, y, 320, sz, 31, 200, 200 );
// y += 20;
if ( Bench_InStage( FIRST_STAGE) /*|| Bench_InStage( SECOND_STAGE ) || Bench_InStage( THIRD_STAGE )*/ || Bench_InStage( FOURTH_STAGE ) )
{
if ( m_fReceiveTime && m_nSentFinish )
{
sprintf( sz, g_stage1[1], Bench_ScoreForValue( FIRST_STAGE, m_StoredLatency ));
}
else
{
strcpy( sz, g_stage1[0] );
}
gHUD.DrawHudString( x, y, 320, sz, 255, 255, 255 );
y += 20;
}
if ( Bench_InStage( SECOND_STAGE )/* || Bench_InStage( THIRD_STAGE )*/ || Bench_InStage( FOURTH_STAGE ) )
{
float avg = 0.0;
if ( m_nFPSCount > 0 )
{
avg = m_fAverageFT / (float)m_nFPSCount;
m_fAvgFrameRate = 1.0 / avg;
}
if ( m_nSentFinish /* Bench_InStage( THIRD_STAGE ) */|| Bench_InStage( FOURTH_STAGE ) )
{
sprintf( sz, g_stage2[1], Bench_ScoreForValue( SECOND_STAGE, m_fAvgFrameRate ) );
}
else
{
strcpy( sz, g_stage2[0] );
}
gHUD.DrawHudString( x, y, 320, sz, 255, 255, 255 );
y += 20;
}
if ( Bench_InStage( THIRD_STAGE ) || Bench_InStage( FOURTH_STAGE ) )
{
if ( m_nSentFinish || Bench_InStage( FOURTH_STAGE ) )
{
sprintf( sz, g_stage3[1], Bench_ScoreForValue( THIRD_STAGE, m_fAvgScore ) );
}
else
{
strcpy( sz, g_stage3[0] );
}
gHUD.DrawHudString( x, y, 320, sz, 255, 255, 255 );
y += 20;
}
if ( Bench_InStage( FOURTH_STAGE ) )
{
sprintf( sz, g_stage4, m_nCompositeScore );
gHUD.DrawHudString( x, y, 320, sz, 31, 200, 200 );
}
m_fDrawTime = gHUD.m_flTime + BENCH_TIME;
return true;
}
