Exemple #1
0
/*
===============
idClipModel::ClearTraceModelCache
===============
*/
void idClipModel::ClearTraceModelCache()
{
	traceModelCache.DeleteContents( true );
	traceModelCache_Unsaved.DeleteContents( true );
	traceModelHash.Free();
	traceModelHash_Unsaved.Free();
}
/*
================
DialogScriptEditor::InitScriptEvents
================
*/
void DialogScriptEditor::InitScriptEvents( void ) {
	int index;
	idParser src;
	idToken token;
	idStr whiteSpace;
	scriptEventInfo_t info;
	if( !src.LoadFile( "script/doom_events.script" ) ) {
		return;
	}
	scriptEvents.Clear();
	while( src.ReadToken( &token ) ) {
		if( token == "scriptEvent" ) {
			src.GetLastWhiteSpace( whiteSpace );
			index = whiteSpace.Find( "//" );
			if( index != -1 ) {
				info.help = whiteSpace.Right( whiteSpace.Length() - index );
				info.help.Remove( '\r' );
				info.help.Replace( "\n", "\r\n" );
			} else {
				info.help = "";
			}
			src.ExpectTokenType( TT_NAME, 0, &token );
			info.parms = token;
			src.ExpectTokenType( TT_NAME, 0, &token );
			info.name = token;
			src.ExpectTokenString( "(" );
			info.parms += " " + info.name + "(";
			while( src.ReadToken( &token ) && token != ";" ) {
				info.parms.Append( " " + token );
			}
			scriptEvents.Append( info );
		}
	}
}
Exemple #3
0
/*
===============
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--;
		
	}
}
/*
================
idAASFileLocal::ParseIndex
================
*/
bool idAASFileLocal::ParseIndex( idLexer &src, idList<aasIndex_t> &indexes )
{
    int numIndexes, i;
    aasIndex_t index;

    numIndexes = src.ParseInt();
    indexes.Resize( numIndexes );
    if ( !src.ExpectTokenString( "{" ) )
    {
        return false;
    }
    for ( i = 0; i < numIndexes; i++ )
    {
        src.ParseInt();
        src.ExpectTokenString( "(" );
        index = src.ParseInt();
        src.ExpectTokenString( ")" );
        indexes.Append( index );
    }
    if ( !src.ExpectTokenString( "}" ) )
    {
        return false;
    }
    return true;
}
/*
===============
idSessionLocal::GetSaveGameList
===============
*/
void idSessionLocal::GetSaveGameList( idStrList &fileList, idList<fileTIME_T> &fileTimes ) {
	int i;
	idFileList *files;

	// NOTE: no fs_game_base for savegames
	idStr game = cvarSystem->GetCVarString( "fs_game" );
	if( game.Length() ) {
		files = fileSystem->ListFiles( "savegames", ".save", false, false, game );
	} else {
		files = fileSystem->ListFiles( "savegames", ".save" );
	}
	
	fileList = files->GetList();
	fileSystem->FreeFileList( files );

	for ( i = 0; i < fileList.Num(); i++ ) {
		ID_TIME_T timeStamp;

		fileSystem->ReadFile( "savegames/" + fileList[i], NULL, &timeStamp );
		fileList[i].StripLeading( '/' );
		fileList[i].StripFileExtension();

		fileTIME_T ft;
		ft.index = i;
		ft.timeStamp = timeStamp;
		fileTimes.Append( ft );
	}

	fileTimes.Sort( idListSaveGameCompare );
}
Exemple #6
0
/*
=================
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" );
}
Exemple #7
0
/*
================
Sys_ClearEvents
================
*/
void Sys_ClearEvents() {
	SDL_Event ev;

	while (SDL_PollEvent(&ev))
		;

	kbd_polls.SetNum(0, false);
	mouse_polls.SetNum(0, false);
}
/*
========================
idParallelJobList_Threads::TryWait
========================
*/
bool idParallelJobList_Threads::TryWait()
{
	if( jobList.Num() == 0 || signalJobCount[signalJobCount.Num() - 1].GetValue() <= 0 )
	{
		Wait();
		return true;
	}
	return false;
}
Exemple #9
0
/*
=================
Sys_InitInput
=================
*/
void Sys_InitInput() {
	kbd_polls.SetGranularity(64);
	mouse_polls.SetGranularity(64);

	SDL_EnableUNICODE(1);
	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);

	in_kbd.SetModified();
}
/*
=================
idRenderModelManagerLocal::RemoveModel
=================
*/
void idRenderModelManagerLocal::RemoveModel( idRenderModel* model )
{
	int index = models.FindIndex( model );
	if( index != -1 )
	{
		hash.RemoveIndex( hash.GenerateKey( model->Name(), false ), index );
		models.RemoveIndex( index );
	}
}
/*
========================
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 );
	}
}
Exemple #12
0
/*
===============
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 );
	}
}
Exemple #13
0
/*
=================
Sys_InitInput
=================
*/
void Sys_InitInput() {
	kbd_polls.SetGranularity(64);
	mouse_polls.SetGranularity(64);

#if !SDL_VERSION_ATLEAST(2, 0, 0)
	SDL_EnableUNICODE(1);
	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
#endif

	in_kbd.SetModified();
}
/*
========================
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( ";" );
}
Exemple #15
0
/*
============
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();
}
/*
=====================================
LeaderboardLocal_Init
=====================================
*/
void LeaderboardLocal_Init()
{

	const idList< mpMap_t > maps = common->GetMapList();
	
	const char** gameModes = NULL;
	const char** gameModesDisplay = NULL;
	int numModes = game->GetMPGameModes( &gameModes, &gameModesDisplay );
	
	// Iterate through all the available maps, and generate leaderboard Defs, and IDs for each.
	for( int mapIdx = 0; mapIdx < maps.Num(); mapIdx++ )
	{
	
		for( int modeIdx = 0; modeIdx < numModes; modeIdx++ )
		{
		
			// Check the supported modes on the map.
			if( maps[ mapIdx ].supportedModes & BIT( modeIdx ) )
			{
			
				const columnGameMode_t gamemode = gameMode_columnDefs[ modeIdx ];
				
				// Generate a Leaderboard ID for the map/mode
				int boardID = LeaderboardLocal_GetID( mapIdx, modeIdx );
				
				
				// Create and Register the leaderboard with the sys_stats registered Leaderboards
				leaderboardDefinition_t* newLeaderboardDef = Sys_CreateLeaderboardDef( boardID,
						gamemode.numColumns,
						gamemode.columnDef,
						gamemode.rankOrder,
						gamemode.supportsAttachments,
						gamemode.checkAgainstCurrent );
						
						
#ifndef USE_STEAM_API
				// Set the leaderboard name.
				const char* mapname = idLocalization::GetString( maps[ mapIdx ].mapName );
				newLeaderboardDef->boardName.Format( "%s %s", mapname, gamemode.abrevName );
#endif
				// sanity check.
				if( Sys_FindLeaderboardDef( boardID ) != newLeaderboardDef )
				{
					idLib::Error( "Leaderboards_Init leaderboard creation failed" );
				}
				
			}
		}
	}
	
}
/*
========================
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() );
	}
}
Exemple #19
0
/*
================
Sys_ClearEvents
================
*/
void Sys_ClearEvents() {
	SDL_Event ev;

	while (SDL_PollEvent(&ev))
		;

	kbd_polls.SetNum(0, false);
	mouse_polls.SetNum(0, false);
	joystick_polls.SetNum(0, false);

	memset( buttonStates, 0, sizeof( buttonStates ) );
	memset( joyAxis, 0, sizeof( joyAxis ) );

	event_overflow.SetNum(0, false);
}
Exemple #20
0
/*
========================
idConsoleLocal::DrawDebugGraphs
========================
*/
void idConsoleLocal::DrawDebugGraphs()
{
	for( int i = 0; i < debugGraphs.Num(); i++ )
	{
		debugGraphs[i]->Render( renderSystem );
	}
}
/*
============
idCVarSystemLocal::CommandCompletion
============
*/
void idCVarSystemLocal::CommandCompletion( void(*callback)( const char *s ) )
{
    for( int i = 0; i < cvars.Num(); i++ )
    {
        callback( cvars[i]->GetName() );
    }
}
Exemple #22
0
/*
=================
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, &current );
			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::Shutdown
============
*/
void idCVarSystemLocal::Shutdown( void )
{
    cvars.DeleteContents( true );
    cvarHash.Free();
    moveCVarsToDict.Clear();
    initialized = false;
}
Exemple #24
0
/*
===============
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--;
}
Exemple #25
0
/*
==============
idConsoleLocal::Shutdown
==============
*/
void idConsoleLocal::Shutdown()
{
	cmdSystem->RemoveCommand( "clear" );
	cmdSystem->RemoveCommand( "conDump" );
	
	debugGraphs.DeleteContents( true );
}
bool idRenderModelBSP29NonMap::Load( idList<byte>& buffer, idSkinTranslation* skinTranslation ) {
	type = MOD_BRUSH29_NON_MAP;
	tr.currentModel = this;

	bsp29_dheader_t* header = ( bsp29_dheader_t* )buffer.Ptr();

	int version = LittleLong( header->version );
	if ( version != BSP29_VERSION ) {
		common->FatalError( "Mod_LoadBrush29Model: %s has wrong version number (%i should be %i)", name, version, BSP29_VERSION );
	}

	// swap all the lumps
	byte* mod_base = ( byte* )header;

	for ( int i = 0; i < ( int )sizeof ( bsp29_dheader_t ) / 4; i++ ) {
		( ( int* )header )[ i ] = LittleLong( ( ( int* )header )[ i ] );
	}

	// load into heap
	idBsp29LoadHelper loader( name, mod_base );
	loader.LoadVertexes( &header->lumps[ BSP29LUMP_VERTEXES ] );
	loader.LoadEdges( &header->lumps[ BSP29LUMP_EDGES ] );
	loader.LoadSurfedges( &header->lumps[ BSP29LUMP_SURFEDGES ] );
	loader.LoadPlanes( &header->lumps[ BSP29LUMP_PLANES ] );
	loader.LoadLighting( &header->lumps[ BSP29LUMP_LIGHTING ] );
	loader.LoadTextures( &header->lumps[ BSP29LUMP_TEXTURES ] );
	loader.LoadTexinfo( &header->lumps[ BSP29LUMP_TEXINFO ] );
	loader.LoadFaces( &header->lumps[ BSP29LUMP_FACES ] );
	delete[] loader.planes;
	brush29nm_lightdata = loader.lightdata;
	brush29nm_numtextures = loader.numtextures;
	brush29nm_textures = loader.textures;
	brush29nm_numtexinfo = loader.numtexinfo;
	brush29nm_texinfo = loader.texinfo;
	brush29nm_textureInfos = loader.textureInfos;
	brush29nm_numsurfaces = loader.numsurfaces;
	brush29nm_surfaces = loader.surfaces;
	if ( GGameType & GAME_Hexen2 ) {
		loader.LoadSubmodelsH2( &header->lumps[ BSP29LUMP_MODELS ] );
	} else {
		loader.LoadSubmodelsQ1( &header->lumps[ BSP29LUMP_MODELS ] );
	}

	q1_numframes = 2;		// regular and alternate animation

	//
	// set up the submodels
	//
	mbrush29_submodel_t* bm = loader.submodels;

	brush29nm_firstmodelsurface = bm->firstface;
	brush29nm_nummodelsurfaces = bm->numfaces;

	VectorCopy( bm->maxs, q1_maxs );
	VectorCopy( bm->mins, q1_mins );

	q1_radius = RadiusFromBounds( q1_mins, q1_maxs );
	delete[] loader.submodels;
	return true;
}
/*
========================
idMenuWidget_NavBar::SetListHeadings
========================
*/
void idMenuWidget_NavBar::SetListHeadings( idList< idStr >& list )
{
	headings.Clear();
	for( int index = 0; index < list.Num(); ++index )
	{
		headings.Append( list[ index ] );
	}
}
Exemple #28
0
/*
================
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;
}
Exemple #29
0
/*
================
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;
}
/*
========================
idMenuWidget_LobbyList::SetHeadingInfo
========================
*/
void idMenuWidget_LobbyList::SetHeadingInfo( idList< idStr >& list )
{
	headings.Clear();
	for( int index = 0; index < list.Num(); ++index )
	{
		headings.Append( list[ index ] );
	}
}