/*
===============
idClipModel::FreeTraceModel
===============
*/
void idClipModel::FreeTraceModel( int traceModelIndex )
{
int realTraceModelIndex = traceModelIndex & ~TRACE_MODEL_SAVED;
// Check which cache we are using.
if( traceModelIndex & TRACE_MODEL_SAVED )
{
if( realTraceModelIndex < 0 || realTraceModelIndex >= traceModelCache.Num() || traceModelCache[realTraceModelIndex]->refCount <= 0 )
{
gameLocal.Warning( "idClipModel::FreeTraceModel: tried to free uncached trace model" );
return;
}
traceModelCache[realTraceModelIndex]->refCount--;
}
else
{
if( realTraceModelIndex < 0 || realTraceModelIndex >= traceModelCache_Unsaved.Num() || traceModelCache_Unsaved[realTraceModelIndex]->refCount <= 0 )
{
gameLocal.Warning( "idClipModel::FreeTraceModel: tried to free uncached trace model" );
return;
}
traceModelCache_Unsaved[realTraceModelIndex]->refCount--;
}
}
/*
========================
idParallelJobList_Threads::InsertSyncPoint
========================
*/
ID_INLINE void idParallelJobList_Threads::InsertSyncPoint( jobSyncType_t syncType )
{
assert( done );
switch( syncType )
{
case SYNC_SIGNAL:
{
assert( !hasSignal );
if( jobList.Num() )
{
assert( !hasSignal );
signalJobCount.Alloc();
signalJobCount[signalJobCount.Num() - 1].SetValue( jobList.Num() - lastSignalJob );
lastSignalJob = jobList.Num();
job_t& job = jobList.Alloc();
job.function = Nop;
job.data = & JOB_SIGNAL;
hasSignal = true;
}
break;
}
case SYNC_SYNCHRONIZE:
{
if( hasSignal )
{
job_t& job = jobList.Alloc();
job.function = Nop;
job.data = & JOB_SYNCHRONIZE;
hasSignal = false;
numSyncs++;
}
break;
}
}
}
/*
=================
idRenderModelManagerLocal::EndLevelLoad
=================
*/
void idRenderModelManagerLocal::EndLevelLoad() {
common->Printf( "----- idRenderModelManagerLocal::EndLevelLoad -----\n" );
int start = Sys_Milliseconds();
insideLevelLoad = false;
int purgeCount = 0;
int keepCount = 0;
int loadCount = 0;
// purge any models not touched
for ( int i = 0 ; i < models.Num() ; i++ ) {
idRenderModel *model = models[i];
if ( !model->IsLevelLoadReferenced() && model->IsLoaded() && model->IsReloadable() ) {
// common->Printf( "purging %s\n", model->Name() );
purgeCount++;
R_CheckForEntityDefsUsingModel( model );
model->PurgeModel();
} else {
// common->Printf( "keeping %s\n", model->Name() );
keepCount++;
}
}
// purge unused triangle surface memory
R_PurgeTriSurfData( frameData );
// load any new ones
for ( int i = 0 ; i < models.Num() ; i++ ) {
idRenderModel *model = models[i];
if ( model->IsLevelLoadReferenced() && !model->IsLoaded() && model->IsReloadable() ) {
loadCount++;
model->LoadModel();
if ( ( loadCount & 15 ) == 0 ) {
session->PacifierUpdate();
}
}
}
// _D3XP added this
int end = Sys_Milliseconds();
common->Printf( "%5i models purged from previous level, ", purgeCount );
common->Printf( "%5i models kept.\n", keepCount );
if ( loadCount ) {
common->Printf( "%5i new models loaded in %5.1f seconds\n", loadCount, (end-start) * 0.001 );
}
common->Printf( "---------------------------------------------------\n" );
}
/*
========================
idParallelJobList_Threads::TryWait
========================
*/
bool idParallelJobList_Threads::TryWait()
{
if( jobList.Num() == 0 || signalJobCount[signalJobCount.Num() - 1].GetValue() <= 0 )
{
Wait();
return true;
}
return false;
}
/*
========================
idParallelJobList_Threads::Submit
========================
*/
void idParallelJobList_Threads::Submit( idParallelJobList_Threads* waitForJobList, int parallelism )
{
assert( done );
assert( numSyncs <= maxSyncs );
assert( ( unsigned int ) jobList.Num() <= maxJobs + numSyncs * 2 );
assert( fetchLock.GetValue() == 0 );
done = false;
currentJob.SetValue( 0 );
memset( &deferredThreadStats, 0, sizeof( deferredThreadStats ) );
deferredThreadStats.numExecutedJobs = jobList.Num() - numSyncs * 2;
deferredThreadStats.numExecutedSyncs = numSyncs;
deferredThreadStats.submitTime = Sys_Microseconds();
deferredThreadStats.startTime = 0;
deferredThreadStats.endTime = 0;
deferredThreadStats.waitTime = 0;
if( jobList.Num() == 0 )
{
return;
}
if( waitForJobList != NULL )
{
waitForGuard = & waitForJobList->doneGuards[waitForJobList->currentDoneGuard];
}
else
{
waitForGuard = NULL;
}
currentDoneGuard = ( currentDoneGuard + 1 ) & ( NUM_DONE_GUARDS - 1 );
doneGuards[currentDoneGuard].SetValue( 1 );
signalJobCount.Alloc();
signalJobCount[signalJobCount.Num() - 1].SetValue( jobList.Num() - lastSignalJob );
job_t& job = jobList.Alloc();
job.function = Nop;
job.data = & JOB_LIST_DONE;
if( threaded )
{
// hand over to the manager
void SubmitJobList( idParallelJobList_Threads * jobList, int parallelism );
SubmitJobList( this, parallelism );
}
else
{
// run all the jobs right here
threadJobListState_t state( GetVersion() );
RunJobs( 0, state, false );
}
}
/*
===============
idClipModel::SaveTraceModels
===============
*/
void idClipModel::SaveTraceModels( idSaveGame *savefile ) {
int i;
savefile->WriteInt( traceModelCache.Num() );
for( i = 0; i < traceModelCache.Num(); i++ ) {
trmCache_t *entry = traceModelCache[i];
savefile->WriteTraceModel( entry->trm );
savefile->WriteFloat( entry->volume );
savefile->WriteVec3( entry->centerOfMass );
savefile->WriteMat3( entry->inertiaTensor );
}
}
/*
========================
idLobby::RemoveSessionUsersByIDList
This is the choke point for removing users from a session.
It will handle all the housekeeping of removing from various platform lists (xsession user tracking, etc).
Called from both host and client.
========================
*/
void idLobby::RemoveSessionUsersByIDList( idList< lobbyUserID_t > & usersToRemoveByID ) {
assert( lobbyBackend != NULL || usersToRemoveByID.Num() == 0 );
for ( int i = 0; i < usersToRemoveByID.Num(); i++ ) {
for ( int u = 0; u < GetNumLobbyUsers(); u++ ) {
lobbyUser_t * user = GetLobbyUser( u );
if ( user->IsDisconnected() ) {
// User already disconnected from session but not removed from the list.
// This will happen when users are removed during the game.
continue;
}
if ( user->lobbyUserID == usersToRemoveByID[i] ) {
if ( lobbyType == TYPE_GAME ) {
idLib::Printf( "NET: %s left the game.\n", user->gamertag );
} else if ( lobbyType == TYPE_PARTY ) {
idLib::Printf( "NET: %s left the party.\n", user->gamertag );
}
UnregisterUser( user );
// Save the user so we can still get his gamertag, which may be needed for
// a disconnection HUD message.
SaveDisconnectedUser( *user );
FreeUser( user );
break;
}
}
}
if ( usersToRemoveByID.Num() > 0 && IsHost() ) {
if ( lobbyBackend != NULL ) {
lobbyBackend->UpdateLobbySkill( GetAverageSessionLevel() );
}
// If we are the host, send a message to all peers with a list of users who have disconnected
byte buffer[ idPacketProcessor::MAX_MSG_SIZE ];
idBitMsg msg( buffer, sizeof( buffer ) );
msg.WriteByte( usersToRemoveByID.Num() );
for ( int i = 0; i < usersToRemoveByID.Num(); i++ ) {
usersToRemoveByID[i].WriteToMsg( msg );
}
for ( int p = 0; p < peers.Num(); p++ ) {
QueueReliableMessage( p, RELIABLE_USER_DISCONNECTED, msg.GetReadData(), msg.GetSize() );
}
}
}
/*
========================
idParallelJobList_Threads::AddJob
========================
*/
ID_INLINE void idParallelJobList_Threads::AddJob( jobRun_t function, void* data )
{
assert( done );
#if defined( _DEBUG )
// make sure there isn't already a job with the same function and data in the list
if( jobList.Num() < 1000 ) // don't do this N^2 slow check on big lists
{
for( int i = 0; i < jobList.Num(); i++ )
{
assert( jobList[i].function != function || jobList[i].data != data );
}
}
#endif
if( 1 ) // JDC: this never worked in tech5! !jobList.IsFull() ) {
{
job_t& job = jobList.Alloc();
job.function = function;
job.data = data;
job.executed = 0;
}
else
{
// debug output to show us what is overflowing
int currentJobCount[MAX_REGISTERED_JOBS] = {};
for( int i = 0; i < jobList.Num(); ++i )
{
const char* jobName = GetJobName( jobList[ i ].function );
for( int j = 0; j < numRegisteredJobs; ++j )
{
if( jobName == registeredJobs[ j ].name )
{
currentJobCount[ j ]++;
break;
}
}
}
// print the quantity of each job type
for( int i = 0; i < numRegisteredJobs; ++i )
{
if( currentJobCount[ i ] > 0 )
{
idLib::Printf( "Job: %s, # %d", registeredJobs[ i ].name, currentJobCount[ i ] );
}
}
idLib::Error( "Can't add job '%s', too many jobs %d", GetJobName( function ), jobList.Num() );
}
}
/*
=================
idRenderModelManagerLocal::ReloadModels
=================
*/
void idRenderModelManagerLocal::ReloadModels( bool forceAll ) {
if( forceAll ) {
common->Printf( "Reloading all model files...\n" );
} else {
common->Printf( "Checking for changed model files...\n" );
}
R_FreeDerivedData();
// skip the default model at index 0
for( int i = 1 ; i < models.Num() ; i++ ) {
idRenderModel *model = models[i];
// we may want to allow world model reloading in the future, but we don't now
if( !model->IsReloadable() ) {
continue;
}
if( !forceAll ) {
// check timestamp
ID_TIME_T current;
fileSystem->ReadFile( model->Name(), NULL, ¤t );
if( current <= model->Timestamp() ) {
continue;
}
}
common->DPrintf( "reloading %s.\n", model->Name() );
model->LoadModel();
}
// we must force the world to regenerate, because models may
// have changed size, making their references invalid
R_ReCreateWorldReferences();
}
/*
============
idCVarSystemLocal::CommandCompletion
============
*/
void idCVarSystemLocal::CommandCompletion( void(*callback)( const char *s ) )
{
for( int i = 0; i < cvars.Num(); i++ )
{
callback( cvars[i]->GetName() );
}
}
/*
========================
idConsoleLocal::DrawDebugGraphs
========================
*/
void idConsoleLocal::DrawDebugGraphs()
{
for( int i = 0; i < debugGraphs.Num(); i++ )
{
debugGraphs[i]->Render( renderSystem );
}
}
/*
===============
idClipModel::FreeTraceModel
===============
*/
void idClipModel::FreeTraceModel( int traceModelIndex ) {
if ( traceModelIndex < 0 || traceModelIndex >= traceModelCache.Num() || traceModelCache[traceModelIndex]->refCount <= 0 ) {
gameLocal.Warning( "idClipModel::FreeTraceModel: tried to free uncached trace model" );
return;
}
traceModelCache[traceModelIndex]->refCount--;
}
clipHandle_t CM_PrecacheModel( const char* Name ) {
if ( !Name[ 0 ] ) {
common->Error( "CM_ForName: NULL name" );
}
//
// search the currently loaded models
//
for ( int i = 0; i < CMNonMapModels.Num(); i++ ) {
if ( CMNonMapModels[ i ]->Name == Name ) {
return ( i + 1 ) << CMH_NON_MAP_SHIFT;
}
}
//
// load the file
//
idList<quint8> Buffer;
if ( FS_ReadFile( Name, Buffer ) <= 0 ) {
common->Error( "CM_PrecacheModel: %s not found", Name );
}
// call the apropriate loader
switch ( LittleLong( *( unsigned* )Buffer.Ptr() ) ) {
case BSP29_VERSION:
{
QClipMap* LoadCMap = CM_CreateQClipMap29();
CMNonMapModels.Append( LoadCMap );
LoadCMap->LoadMap( Name, Buffer );
if ( LoadCMap->GetNumInlineModels() > 1 ) {
common->Printf( "Non-map BSP models are not supposed to have submodels\n" );
}
break;
}
default:
{
QClipMapNonMap* LoadCMap = new QClipMapNonMap;
CMNonMapModels.Append( LoadCMap );
LoadCMap->LoadMap( Name, Buffer );
}
}
return CMNonMapModels.Num() << CMH_NON_MAP_SHIFT;
}
int Sys_ReturnJoystickInputEvent( const int n, int &action, int &value ) {
if (n >= joystick_polls.Num())
return 0;
action = joystick_polls[n].action;
value = joystick_polls[n].value;
return 1;
}
/*
============
idCVarSystemLocal::WriteFlaggedVariables
Appends lines containing "set variable value" for all variables
with the "flags" flag set to true.
============
*/
void idCVarSystemLocal::WriteFlaggedVariables( int flags, const char *setCmd, idFile *f ) const {
for( int i = 0; i < cvars.Num(); i++ ) {
idInternalCVar *cvar = cvars[i];
if ( cvar->GetFlags() & flags ) {
f->Printf( "%s %s \"%s\"\n", setCmd, cvar->GetName(), cvar->GetString() );
}
}
}
/*
=================
idRenderModelManagerLocal::FreeModelVertexCaches
=================
*/
void idRenderModelManagerLocal::FreeModelVertexCaches()
{
for( int i = 0; i < models.Num(); i++ )
{
idRenderModel* model = models[i];
model->FreeVertexCache();
}
}
/*
================
Sys_ReturnKeyboardInputEvent
================
*/
int Sys_ReturnKeyboardInputEvent(const int n, int &key, bool &state) {
if (n >= kbd_polls.Num())
return 0;
key = kbd_polls[n].key;
state = kbd_polls[n].state;
return 1;
}
/*
================
Sys_ReturnMouseInputEvent
================
*/
int Sys_ReturnMouseInputEvent(const int n, int &action, int &value) {
if (n >= mouse_polls.Num())
return 0;
action = mouse_polls[n].action;
value = mouse_polls[n].value;
return 1;
}
/*
========================
idMenuWidget_NavBar::SetListHeadings
========================
*/
void idMenuWidget_NavBar::SetListHeadings( idList< idStr >& list )
{
headings.Clear();
for( int index = 0; index < list.Num(); ++index )
{
headings.Append( list[ index ] );
}
}
/*
========================
idMenuWidget_LobbyList::SetHeadingInfo
========================
*/
void idMenuWidget_LobbyList::SetHeadingInfo( idList< idStr >& list )
{
headings.Clear();
for( int index = 0; index < list.Num(); ++index )
{
headings.Append( list[ index ] );
}
}
/*
============
idCVarSystemLocal::RemoveFlaggedAutoCompletion
============
*/
void idCVarSystemLocal::RemoveFlaggedAutoCompletion( int flags ) {
for( int i = 0; i < cvars.Num(); i++ ) {
idInternalCVar *cvar = cvars[i];
if ( cvar->GetFlags() & flags ) {
cvar->valueCompletion = NULL;
}
}
}
/*
============
idCVarSystemLocal::ResetFlaggedVariables
============
*/
void idCVarSystemLocal::ResetFlaggedVariables( int flags ) {
for( int i = 0; i < cvars.Num(); i++ ) {
idInternalCVar *cvar = cvars[i];
if ( cvar->GetFlags() & flags ) {
cvar->Set( NULL, true, true );
}
}
}
/*
================
GetToolTip
================
*/
bool GetToolTip( const char *name, CString &string ) {
for( int i = 0; i < scriptEvents.Num(); i++ ) {
if( scriptEvents[i].name.Cmp( name ) == 0 ) {
string = scriptEvents[i].help + scriptEvents[i].parms;
return true;
}
}
return false;
}
/*
========================
idMenuScreen_Shell_MatchSettings::idMenuDataSource_MatchSettings::GetMapName
========================
*/
void idMenuScreen_Shell_MatchSettings::idMenuDataSource_MatchSettings::GetMapName( int index, idStr & name ) {
idLobbyBase & lobby = session->GetActivePlatformLobbyBase();
const idMatchParameters & matchParameters = lobby.GetMatchParms();
name = "#str_swf_filter_random";
if ( matchParameters.gameMap >= 0 ) {
const idList< mpMap_t > maps = common->GetMapList();
name = idLocalization::GetString( maps[ idMath::ClampInt( 0, maps.Num() - 1, matchParameters.gameMap ) ].mapName );
}
}
/*
================
GetFunctionParms
================
*/
bool GetFunctionParms( const char *funcName, CString &parmString ) {
for( int i = 0; i < scriptEvents.Num(); i++ ) {
if( scriptEvents[i].name.Cmp( funcName ) == 0 ) {
parmString = scriptEvents[i].parms;
return true;
}
}
return false;
}
/*
========================
idMenuWidget_DynamicList::SetListData
========================
*/
void idMenuWidget_DynamicList::SetListData( idList< idList< idStr, TAG_IDLIB_LIST_MENU >, TAG_IDLIB_LIST_MENU > & list ) {
listItemInfo.Clear();
for ( int i = 0; i < list.Num(); ++i ) {
idList< idStr > values;
for ( int j = 0; j < list[i].Num(); ++j ) {
values.Append( list[i][j] );
}
listItemInfo.Append( values );
}
}
/*
============
idCVarSystemLocal::MoveCVarsToDict
============
*/
const idDict* idCVarSystemLocal::MoveCVarsToDict( int flags ) const {
moveCVarsToDict.Clear();
for( int i = 0; i < cvars.Num(); i++ ) {
idCVar *cvar = cvars[i];
if ( cvar->GetFlags() & flags ) {
moveCVarsToDict.Set( cvar->GetName(), cvar->GetString() );
}
}
return &moveCVarsToDict;
}
/*
========================
ParseInOutStruct
========================
*/
void ParseInOutStruct( idLexer & src, int attribType, idList< inOutVariable_t > & inOutVars ) {
src.ExpectTokenString( "{" );
while( !src.CheckTokenString( "}" ) ) {
inOutVariable_t var;
idToken token;
src.ReadToken( &token );
var.type = token;
src.ReadToken( &token );
var.nameCg = token;
if ( !src.CheckTokenString( ":" ) ) {
src.SkipUntilString( ";" );
continue;
}
src.ReadToken( &token );
var.nameGLSL = token;
src.ExpectTokenString( ";" );
// convert the type
for ( int i = 0; typeConversion[i].typeCG != NULL; i++ ) {
if ( var.type.Cmp( typeConversion[i].typeCG ) == 0 ) {
var.type = typeConversion[i].typeGLSL;
break;
}
}
// convert the semantic to a GLSL name
for ( int i = 0; attribsPC[i].semantic != NULL; i++ ) {
if ( ( attribsPC[i].flags & attribType ) != 0 ) {
if ( var.nameGLSL.Cmp( attribsPC[i].semantic ) == 0 ) {
var.nameGLSL = attribsPC[i].glsl;
break;
}
}
}
// check if it was defined previously
var.declareInOut = true;
for ( int i = 0; i < inOutVars.Num(); i++ ) {
if ( var.nameGLSL == inOutVars[i].nameGLSL ) {
var.declareInOut = false;
break;
}
}
inOutVars.Append( var );
}
src.ExpectTokenString( ";" );
}
/*
============
idBrush::FromSides
============
*/
bool idBrush::FromSides( idList<idBrushSide*>& sideList )
{
int i;
for( i = 0; i < sideList.Num(); i++ )
{
sides.Append( sideList[i] );
}
sideList.Clear();
return CreateWindings();
}
/*
========================
idMenuScreen_Scoreboard::SetPlayerData
========================
*/
void idMenuScreen_Scoreboard::SetPlayerData( idList< scoreboardInfo_t, TAG_IDLIB_LIST_MENU > data ) {
if ( playerList != NULL ) {
for ( int i = 0; i < data.Num(); ++i ) {
if ( i < playerList->GetChildren().Num() ) {
idMenuWidget_ScoreboardButton * button = dynamic_cast< idMenuWidget_ScoreboardButton * >( &playerList->GetChildByIndex( i ) );
if ( button != NULL ) {
button->SetButtonInfo( data[i].index, data[i].values, data[i].voiceState );
}
}
playerList->Update();
}
}
}
