自学教程：C++ FS_FOpenFileRead函数代码示例

/*=================S_CodecUtilOpen=================*/snd_stream_t *S_CodecUtilOpen(const char *filename, snd_codec_t *codec){    snd_stream_t *stream;    fileHandle_t hnd;    int length;    // Try to open the file    length = FS_FOpenFileRead(filename, &hnd, qtrue);    if(!hnd)    {        Com_Printf(_("Can't read sound file %s/n"), filename);        return NULL;    }    // Allocate a stream    stream = Z_Malloc(sizeof(snd_stream_t));    if(!stream)    {        FS_FCloseFile(hnd);        return NULL;    }    // Copy over, return    stream->codec = codec;    stream->file = hnd;    stream->length = length;    return stream;}

/*================SV_TouchFile================*/static void SV_TouchFile( const char *filename ) {	fileHandle_t	f;	FS_FOpenFileRead( filename, &f, qfalse );	if ( f ) {		FS_FCloseFile( f );	}}

/*================SV_TouchCGameTouch the cgame.qvm and ui.qvm so that a pure client can load it if it's in a seperate pk3, and so it gets on the download list================*/static void SV_TouchCGame(void) {	fileHandle_t	f;	FS_FOpenFileRead( "vm/cgame.qvm", &f, qfalse );	if ( f ) {		FS_FCloseFile( f );	} else if ( sv_pure->integer ) {		Com_Printf( "WARNING: No cgame.qvm found on pure server/n" );	}	FS_FOpenFileRead( "vm/ui.qvm", &f, qfalse );	if ( f ) {		FS_FCloseFile( f );	} else if ( sv_pure->integer ) {		Com_Printf( "WARNING: No ui.qvm found on pure server/n" );	}}

qboolean S_FileExists(char *fileName) {	fileHandle_t f;	COM_StripExtension(fileName, fileName);	COM_DefaultExtension(fileName, MAX_QPATH, ".wav");	FS_FOpenFileRead(fileName, &f, qtrue);	if (!f) {#ifdef HAVE_LIBMAD		COM_StripExtension(fileName, fileName);		COM_DefaultExtension(fileName, MAX_QPATH, ".mp3");		FS_FOpenFileRead(fileName, &f, qtrue);		if (!f)#endif			return qfalse;	}	FS_FCloseFile(f);	return qtrue;}

/*================SV_TouchCGame  touch cgame so that a pure client can load it if it's in a seperate pk3================*/void SV_TouchCGame( void ){	fileHandle_t f;	FS_FOpenFileRead( "vm/cgame.qvm", &f, qfalse );	if ( f )	{		FS_FCloseFile( f );	}	// LLVM - even if the server doesn't use llvm itself, it should still add the references.	FS_FOpenFileRead( "cgamellvm.bc", &f, qfalse );	if ( f )	{		FS_FCloseFile( f );	}}

/*================SV_TouchCGame  touch the cgame.vm so that a pure client can load it if it's in a seperate pk3================*/void SV_TouchCGame(void) {    fileHandle_t	f;    char filename[MAX_QPATH];    Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", "cgame" );    FS_FOpenFileRead( filename, &f, qfalse );    if ( f ) {        FS_FCloseFile( f );    }}

void BotLoadOffMeshConnections( const char *filename, NavData_t *nav ){	char mapname[ MAX_QPATH ];	char filePath[ MAX_QPATH ];	fileHandle_t f = 0;	Cvar_VariableStringBuffer( "mapname", mapname, sizeof( mapname ) );	Com_sprintf( filePath, sizeof( filePath ), "maps/%s-%s.navcon", mapname, filename );	FS_FOpenFileRead( filePath, &f, qtrue );	if ( !f )	{		return;	}	OffMeshConnectionHeader header;	FS_Read( &header, sizeof( header ), f );	header.version = LittleLong( header.version );	header.numConnections = LittleLong( header.numConnections );	if ( header.version != NAVMESHCON_VERSION )	{		FS_FCloseFile( f );		return;	}	int conCount = header.numConnections;	if ( conCount > nav->process.con.MAX_CON )	{		FS_FCloseFile( f );		return;	}	nav->process.con.offMeshConCount = conCount;	FS_Read( nav->process.con.verts, sizeof( float ) * 6 * conCount, f );	SwapArray( nav->process.con.verts, conCount * 6 );	FS_Read( nav->process.con.rad, sizeof( float ) * conCount, f );	SwapArray( nav->process.con.rad, conCount );	FS_Read( nav->process.con.flags, sizeof( unsigned short ) * conCount, f );	SwapArray( nav->process.con.flags, conCount );	FS_Read( nav->process.con.areas, sizeof( unsigned char ) * conCount, f );	FS_Read( nav->process.con.dirs, sizeof( unsigned char ) * conCount, f );	FS_Read( nav->process.con.userids, sizeof( unsigned int ) * conCount, f );	SwapArray( nav->process.con.userids, conCount );	FS_FCloseFile( f );}

int	FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode ){	FS_CheckInit();	if (mode != FS_READ)	{		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );		return -1;	}		return FS_FOpenFileRead( qpath, f, qtrue );}

static openSound_t *S_StreamOpen( const char *fileName, int dataSize ) {	fileHandle_t fileHandle = 0;	int fileSize = 0;	openSound_t *open;	fileSize = FS_FOpenFileRead( fileName, &fileHandle, qtrue );	if ( fileSize <= 0 || fileHandle <= 0)		return 0;	open = Z_Malloc( sizeof( openSound_t ) + dataSize );	open->fileSize = fileSize;	open->fileHandle = fileHandle;	return open;}

/*====================CL_WalkDemoExt====================*/static int CL_WalkDemoExt(char *arg, char *name, int *demofile){	int i = 0;	*demofile = 0;	Com_sprintf(name, MAX_OSPATH, "demos/%s.%s%d", arg, DEMOEXT, PROTOCOL_VERSION);	FS_FOpenFileRead(name, demofile, qtrue);	if (*demofile)	{		Com_FuncPrinf("Demo file: %s/n", name);		return PROTOCOL_VERSION;	}	Com_FuncPrinf("Not found: %s/n", name);	while (demo_protocols[i])	{		if (demo_protocols[i] == PROTOCOL_VERSION)		{			continue;		}		Com_sprintf(name, MAX_OSPATH, "demos/%s.%s%d", arg, DEMOEXT, demo_protocols[i]);		FS_FOpenFileRead(name, demofile, qtrue);		if (*demofile)		{			Com_FuncPrinf("Demo file: %s/n", name);			return demo_protocols[i];		}		else		{			Com_FuncPrinf("Not found: %s/n", name);		}		i++;	}	return -1;}

qboolean dmaHD_LoadSound(sfx_t *sfx){	byte *data;	snd_info_t info;	char dmahd_soundName[MAX_QPATH];	char *lpext;	// Player specific sounds are never directly loaded.	if (sfx->soundName[0] == '*') return qfalse;	strcpy(dmahd_soundName, sfx->soundName);	if ((lpext = strrchr(sfx->soundName, '.')) != NULL)	{		strcpy(dmahd_soundName, sfx->soundName);		*(strrchr(dmahd_soundName, '.')) = '/0'; // for sure there is a '.'	}	strcat(dmahd_soundName, "_dmahd");	if (lpext != NULL) strcat(dmahd_soundName, lpext);	// Just check if file exists	if (FS_FOpenFileRead(dmahd_soundName, NULL, qtrue) == qtrue)	{		// Load it in.		if (!(data = S_CodecLoad(dmahd_soundName, &info))) return qfalse;	}	else	{		// Load it in.		if (!(data = S_CodecLoad(sfx->soundName, &info))) return qfalse;	}	// Information	Com_DPrintf("Loading sound: %s", sfx->soundName);	if (info.width == 1) Com_DPrintf(" [8 bit -> 16 bit]");	if (info.rate != dma.speed) Com_DPrintf(" [%d Hz -> %d Hz]", info.rate, dma.speed);	Com_DPrintf("/n");	sfx->lastTimeUsed = Com_Milliseconds() + 1;	// Do not compress.	sfx->soundCompressionMethod = 0;	sfx->soundLength = info.samples;	sfx->soundData = NULL;	dmaHD_ResampleSfx(sfx, info.rate, info.width, data + info.dataofs, qfalse);		// Free data allocated by Codec	Z_Free(data);	return qtrue;}

/*============FS_ReadFileFilename are relative to the quake search patha null buffer will just return the file length without loading============*/int FS_ReadFile( const char *qpath, void **buffer ){	FS_CheckInit();		if ( !qpath || !qpath[0] ) {		Com_Error( ERR_FATAL, "FS_ReadFile with empty name/n" );	}	// stop sounds from repeating	S_ClearSoundBuffer();	fileHandle_t h;	int len = FS_FOpenFileRead( qpath, &h, qfalse );	if ( h == 0 )	{		if ( buffer ) *buffer = NULL;		return -1;	}		if ( !buffer )	{		FS_FCloseFile(h);		return len;	}	byte *buf;	// Try to TempAlloc if we've got the hint that this could fail:	if( sbLargeRead )		buf = (byte *)BonePoolTempAlloc( len+1 );	// If that didn't work, or wasn't suggested:	if( !sbLargeRead || !buf )		buf = (byte*)Z_Malloc( len+1, TAG_TEMP_WORKSPACE, qfalse, 32);	buf[len]='/0';//	Z_Label(buf, qpath);	FS_Read(buf, len, h);	// guarantee that it will have a trailing 0 for string operations	buf[len] = 0;	FS_FCloseFile( h );	*buffer = buf;	return len;}

/*====================SV_SetExpectedHunkUsage  Sets com_expectedhunkusage, so the client knows how to draw the percentage bar====================*/void SV_SetExpectedHunkUsage( char *mapname ){	int  handle;	const char *memlistfile = "hunkusage.dat";	char *buf;	char *buftrav;	char *token;	int  len;	len = FS_FOpenFileRead( memlistfile, &handle, qfalse );	if ( len >= 0 )	{		// the file exists, so read it in, strip out the current entry for this map, and save it out, so we can append the new value		buf = ( char * ) Z_Malloc( len + 1 );		memset( buf, 0, len + 1 );		FS_Read( ( void * ) buf, len, handle );		FS_FCloseFile( handle );		// now parse the file, filtering out the current map		buftrav = buf;		while ( ( token = COM_Parse( &buftrav ) ) != NULL && token[ 0 ] )		{			if ( !Q_stricmp( token, mapname ) )			{				// found a match				token = COM_Parse( &buftrav );  // read the size				if ( token && token[ 0 ] )				{					// this is the usage					com_expectedhunkusage = atoi( token );					Z_Free( buf );					return;				}			}		}		Z_Free( buf );	}	// just set it to a negative number,so the cgame knows not to draw the percent bar	com_expectedhunkusage = -1;}

/*================SV_TouchCGame  touch the cgame.vm so that a pure client can load it if it's in a seperate pk3================*/void SV_TouchCGame(void) {	fileHandle_t	f;	char filename[MAX_QPATH];	if (Cvar_VariableValue( "vm_cgame" ))	{		Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", "cgame" );	}	else	{		Com_sprintf( filename, sizeof(filename), "cgamex86.dll" );	}	FS_FOpenFileRead( filename, &f, qfalse );	if ( f ) {		FS_FCloseFile( f );	}}

/*==================CON_Hist_Load==================*/void CON_Hist_Load( void ) {	fileHandle_t f;	long len = FS_FOpenFileRead("conhist.log", &f, qtrue);	if (f) {		field_t tf {};		for (long i = 0; i < len; i++) {			char c;			FS_Read(&c, 1, f);			if (c == '/n') {				Hist_Add(&tf);				tf = {};			} else {				tf.buffer[tf.cursor++] = c;			}		}		FS_FCloseFile(f);	}}

/*=================S_WAV_CodecLoad=================*/void *S_WAV_CodecLoad(const char *filename, snd_info_t *info){	fileHandle_t file;	void         *buffer;	// Try to open the file	FS_FOpenFileRead(filename, &file, qtrue);	if (!file)	{		if (com_developer->integer)		{			Com_Printf(S_COLOR_RED "ERROR: Could not open /"%s/"/n", filename);		}		return NULL;	}	// Read the RIFF header	if (!S_ReadRIFFHeader(file, info))	{		FS_FCloseFile(file);		if (com_developer->integer)		{			Com_Printf(S_COLOR_RED "ERROR: Incorrect/unsupported format in /"%s/"/n", filename);		}		return NULL;	}	// Allocate some memory	buffer = Z_Malloc(info->size);	if (!buffer)	{		FS_FCloseFile(file);		Com_Printf(S_COLOR_RED "ERROR: Out of memory reading /"%s/"/n", filename);		return NULL;	}	// Read, byteswap	FS_Read(buffer, info->size, file);	S_ByteSwapRawSamples(info->samples, info->width, info->channels, (byte *)buffer);	// Close and return	FS_FCloseFile(file);	return buffer;}

void LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) {		*pic = NULL;			fileHandle_t	h;	const int len = FS_FOpenFileRead( filename, &h, qfalse );	if(!h)	{		return;	}	//JPEG system reads 4K past input buffer so we tack on an additional 4k.	byte *pJPGData = (byte *)Z_Malloc(len + 4096, TAG_TEMP_WORKSPACE, qfalse);	FS_Read(pJPGData, len, h);	FS_FCloseFile( h );	Decompress_JPG( filename, pJPGData, pic, width, height );	Z_Free (pJPGData);}

int FS_ReadFile(const char* path, void** buffer){	fileHandle_t handle;	int length = FS_FOpenFileRead(path, &handle, true);	if (length < 0) {		if (buffer)			*buffer = nullptr;		return -1;	}	if (buffer) {		char* buf = new char[length + 1];		*buffer = buf;		FS_Read(buf, length, handle);		buf[length] = '/0';	}	FS_FCloseFile(handle);	return length;}

/*============FS_ReadFileFilename are relative to the quake search patha null buffer will just return the file length without loading============*/int FS_ReadFile( const char *qpath, void **buffer ){	FS_CheckInit();		if ( !qpath || !qpath[0] ) {		Com_Error( ERR_FATAL, "FS_ReadFile with empty name/n" );	}	// stop sounds from repeating	S_ClearSoundBuffer();	fileHandle_t h;	int len = FS_FOpenFileRead( qpath, &h, qfalse );	if ( h == 0 )	{		if ( buffer ) *buffer = NULL;		return -1;	}		if ( !buffer )	{		FS_FCloseFile(h);		return len;	}	// assume temporary....	byte* buf = (byte*)Z_Malloc( len+1, TAG_TEMP_WORKSPACE, qfalse, 32);	buf[len]='/0';//	Z_Label(buf, qpath);	FS_Read(buf, len, h);	// guarantee that it will have a trailing 0 for string operations	buf[len] = 0;	FS_FCloseFile( h );	*buffer = buf;	return len;}

/*====================LAN_LoadCachedServers====================*/void LAN_LoadCachedServers( void ){	int          size;	fileHandle_t fileIn;	char         filename[ MAX_QPATH ];	cls.numglobalservers = cls.numfavoriteservers = 0;	cls.numGlobalServerAddresses = 0;	if ( cl_profile->string[ 0 ] )	{		Com_sprintf( filename, sizeof( filename ), "profiles/%s/servercache.dat", cl_profile->string );	}	else	{		Q_strncpyz( filename, "servercache.dat", sizeof( filename ) );	}	// Arnout: moved to mod/profiles dir	//if (FS_SV_FOpenFileRead(filename, &fileIn)) {	if ( FS_FOpenFileRead( filename, &fileIn, qtrue ) )	{		FS_Read( &cls.numglobalservers, sizeof( int ), fileIn );		FS_Read( &cls.numfavoriteservers, sizeof( int ), fileIn );		FS_Read( &size, sizeof( int ), fileIn );		if ( size == sizeof( cls.globalServers ) + sizeof( cls.favoriteServers ) )		{			FS_Read( &cls.globalServers, sizeof( cls.globalServers ), fileIn );			FS_Read( &cls.favoriteServers, sizeof( cls.favoriteServers ), fileIn );		}		else		{			cls.numglobalservers = cls.numfavoriteservers = 0;			cls.numGlobalServerAddresses = 0;		}		FS_FCloseFile( fileIn );	}}

/* * Finds the file in the search path. Returns filesize and an open FILE *. Used * for streaming data out of either a pak file or a seperate file. */intFS_FOpenFile(const char *name, fileHandle_t *f, fsMode_t mode){	int size = 0;	fsHandle_t *handle;	handle = FS_HandleForFile(name, f);	Q_strlcpy(handle->name, name, sizeof(handle->name));	handle->mode = mode;	switch (mode)	{		case FS_READ:			size = FS_FOpenFileRead(handle);			break;		case FS_WRITE:			size = FS_FOpenFileWrite(handle);			break;		case FS_APPEND:			size = FS_FOpenFileAppend(handle);			break;		default:			Com_Error(ERR_FATAL, "FS_FOpenFile: bad mode (%i)", mode);			break;	}	if (size != -1)	{		return size;	}	/* Couldn't open, so free the handle. */	memset(handle, 0, sizeof(*handle));	*f = 0;	return -1;}

qboolean S_FileExists(char *fileName) {	char *voice = strstr(fileName,"chars");	fileHandle_t f;	int i;	if (voice && s_language) {		if (stricmp("DEUTSCH",s_language->string)==0) {							strncpy(voice,"chr_d",5);	// same number of letters as "chars"		} else if (stricmp("FRANCAIS",s_language->string)==0) {							strncpy(voice,"chr_f",5);	// same number of letters as "chars"		} else if (stricmp("ESPANOL",s_language->string)==0) {							strncpy(voice,"chr_e",5);	// same number of letters as "chars"		} else {			voice = NULL;	// use this ptr as a flag as to whether or not we substituted with a foreign version		}	}tryDefaultLanguage:	i = 0;	while (ext[i]) {		COM_StripExtension(fileName, fileName, MAX_QPATH);		COM_DefaultExtension(fileName, MAX_QPATH, ext[i]);		FS_FOpenFileRead(fileName, &f, qtrue);		if (f)			break;		i++;	}	/* switch back to english (default) and try again */	if (!f && voice) {		strncpy(voice, "chars", 5);		voice = NULL;		goto tryDefaultLanguage;	}	if (!f)		return qfalse;	FS_FCloseFile(f);	return qtrue;}

/** * @brief LAN_LoadCachedServers */void LAN_LoadCachedServers(void){    int32_t      size;    fileHandle_t fileIn;    char         filename[MAX_QPATH];    cls.numglobalservers         = cls.numfavoriteservers = 0;    cls.numGlobalServerAddresses = 0;    if (cl_profile->string[0])    {        Com_sprintf(filename, sizeof(filename), "profiles/%s/favcache.dat", cl_profile->string);    }    else    {        Q_strncpyz(filename, "favcache.dat", sizeof(filename));    }    // moved to mod/profiles dir    if (FS_FOpenFileRead(filename, &fileIn, qtrue))    {        FS_Read(&cls.numfavoriteservers, sizeof(int32_t), fileIn);        FS_Read(&size, sizeof(int32_t), fileIn);        if (size == sizeof(cls.favoriteServers))        {            FS_Read(&cls.favoriteServers, sizeof(cls.favoriteServers), fileIn);        }        else        {            cls.numfavoriteservers = 0;        }        FS_FCloseFile(fileIn);    }    Com_Printf("Total favourite servers restored: %i/n", cls.numfavoriteservers);}

qboolean demoCut(const char *oldName, int startTime, int endTime) {	fileHandle_t	oldHandle = 0;	fileHandle_t	newHandle = 0;	msg_t			oldMsg;	byte			oldData[MAX_MSGLEN];	int				oldSize;	char			newName[MAX_OSPATH];	int				buf;	int				readGamestate = 0;	int				i;	demoPlay_t		*play = demo.play.handle;	qboolean		ret = qfalse;	int				framesSaved = 0;	char			newGameDir[MAX_QPATH];	char			next;	char			*ext;	if (!play) {		Com_Printf("Demo cutting is allowed in mme mode only./n");		return qfalse;	}	startTime += play->startTime;	endTime += play->startTime;	ext = Cvar_FindVar("mme_demoExt")->string;	if (!*ext)		ext = ".dm_26";	oldSize = FS_FOpenFileRead(va("demos/%s%s", oldName, ext), &oldHandle, qtrue);	if (!oldHandle) {		Com_Printf("Failed to open %s for cutting./n", oldName);		return qfalse;	}	memset(&demo.cut.Clc, 0, sizeof(demo.cut.Clc));	Com_SetLoadingMsg("Cutting the demo...");	while (oldSize > 0) {cutcontinue:		MSG_Init(&oldMsg, oldData, sizeof(oldData));		/* Read the sequence number */		if (FS_Read(&demo.cut.Clc.serverMessageSequence, 4, oldHandle) != 4)			goto cuterror;		demo.cut.Clc.serverMessageSequence = LittleLong(demo.cut.Clc.serverMessageSequence);		oldSize -= 4;		/* Read the message size */		if (FS_Read(&oldMsg.cursize,4, oldHandle) != 4)			goto cuterror;		oldMsg.cursize = LittleLong(oldMsg.cursize);		oldSize -= 4;		/* Negative size signals end of demo */		if (oldMsg.cursize < 0)			break;		if (oldMsg.cursize > oldMsg.maxsize) 			goto cuterror;		/* Read the actual message */		if (FS_Read(oldMsg.data, oldMsg.cursize, oldHandle) != oldMsg.cursize)			goto cuterror;		oldSize -= oldMsg.cursize;		// init the bitstream		MSG_BeginReading(&oldMsg);		// Skip the reliable sequence acknowledge number		MSG_ReadLong(&oldMsg);		//		// parse the message		//		while (1) {			byte cmd;			if (oldMsg.readcount > oldMsg.cursize) {				Com_Printf("Demo cutter, read past end of server message./n");				goto cuterror;			}            cmd = MSG_ReadByte(&oldMsg);			if (cmd == svc_EOF) {                break;			}			// skip all the gamestates until we reach needed			if (readGamestate < demo.currentNum) {				if (cmd == svc_gamestate) {					readGamestate++;				}				goto cutcontinue;			}			// other commands			switch (cmd) {			default:				Com_Printf(S_COLOR_RED"ERROR: CL_ParseServerMessage: Illegible server message/n");				goto cuterror;					case svc_nop:				break;			case svc_serverCommand:				demoCutParseCommandString(&oldMsg, &demo.cut.Clc);				break;			case svc_gamestate:				if (readGamestate > demo.currentNum) {					Com_Printf("Warning: unexpected new gamestate, finishing cutting./n");					goto cutcomplete;				}				if (!demoCutParseGamestate(&oldMsg, &demo.cut.Clc, &demo.cut.Cl)) {					goto cuterror;				}				Com_sprintf(newName, sizeof(newName), "demos/%s_cut%s", oldName, ext);				newHandle = FS_FOpenFileWrite(newName);				if (!newHandle) {					Com_Printf("Failed to open %s for target cutting./n", newName);//.........这里部分代码省略.........

bool BotLoadNavMesh( const char *filename, NavData_t &nav ){	char mapname[ MAX_QPATH ];	char filePath[ MAX_QPATH ];	char gameName[ MAX_STRING_CHARS ];	fileHandle_t f = 0;	BotLoadOffMeshConnections( filename, &nav );	Cvar_VariableStringBuffer( "mapname", mapname, sizeof( mapname ) );	Cvar_VariableStringBuffer( "fs_game", gameName, sizeof( gameName ) );	Com_sprintf( filePath, sizeof( filePath ), "maps/%s-%s.navMesh", mapname, filename );	Com_Printf( " loading navigation mesh file '%s'.../n", filePath );	int len = FS_FOpenFileRead( filePath, &f, qtrue );	if ( !f )	{		Com_Printf( S_COLOR_RED "ERROR: Cannot open Navigaton Mesh file/n" );		return false;	}	if ( len < 0 )	{		Com_Printf( S_COLOR_RED "ERROR: Negative Length for Navigation Mesh file/n" );		return false;	}	NavMeshSetHeader header;		FS_Read( &header, sizeof( header ), f );	SwapNavMeshSetHeader( header );	if ( header.magic != NAVMESHSET_MAGIC )	{		Com_Printf( S_COLOR_RED "ERROR: File is wrong magic/n" );		FS_FCloseFile( f );		return false;	}	if ( header.version != NAVMESHSET_VERSION )	{		Com_Printf( S_COLOR_RED "ERROR: File is wrong version found: %d want: %d/n", header.version, NAVMESHSET_VERSION );		FS_FCloseFile( f );		return false;	}	nav.mesh = dtAllocNavMesh();	if ( !nav.mesh )	{		Com_Printf( S_COLOR_RED "ERROR: Unable to allocate nav mesh/n" );		FS_FCloseFile( f );		return false;	}	dtStatus status = nav.mesh->init( &header.params );	if ( dtStatusFailed( status ) )	{		Com_Printf( S_COLOR_RED "ERROR: Could not init navmesh/n" );		dtFreeNavMesh( nav.mesh );		nav.mesh = NULL;		FS_FCloseFile( f );		return false;	}	nav.cache = dtAllocTileCache();	if ( !nav.cache )	{		Com_Printf( S_COLOR_RED "ERROR: Could not allocate tile cache/n" );		dtFreeNavMesh( nav.mesh );		nav.mesh = NULL;		FS_FCloseFile( f );		return false;	}	status = nav.cache->init( &header.cacheParams, &alloc, &comp, &nav.process );	if ( dtStatusFailed( status ) )	{		Com_Printf( S_COLOR_RED "ERROR: Could not init tile cache/n" );		dtFreeNavMesh( nav.mesh );		dtFreeTileCache( nav.cache );		nav.mesh = NULL;		nav.cache = NULL;		FS_FCloseFile( f );		return false;	}	for ( int i = 0; i < header.numTiles; i++ )	{		NavMeshTileHeader tileHeader;		FS_Read( &tileHeader, sizeof( tileHeader ), f );		SwapNavMeshTileHeader( tileHeader );//.........这里部分代码省略.........

 Rocket::Core::FileHandle Open(const Rocket::Core::String& filePath) {     fileHandle_t fileHandle;     FS_FOpenFileRead(filePath.CString(), &fileHandle, false);     return (Rocket::Core::FileHandle) fileHandle; }

Rocket::Core::String Rocket_QuakeToRML(const char* in, int parseFlags = 0) {    const char* p;    Rocket::Core::String out;    Rocket::Core::String spanstr;    bool span = false;    bool spanHasContent = false;    if (!*in) {        return "";    }    for (p = in; p && *p; ++p) {        if (*p == '<') {            if (span && !spanHasContent) {                spanHasContent = true;                out.Append(spanstr);            }            out.Append("&lt;");        } else if (*p == '>') {            if (span && !spanHasContent) {                spanHasContent = true;                out.Append(spanstr);            }            out.Append("&gt;");        } else if (*p == '&') {            if (span && !spanHasContent) {                spanHasContent = true;                out.Append(spanstr);            }            out.Append("&amp;");        } else if (*p == '/n') {            out.Append(span && spanHasContent ? "</span><br />" : "<br />");            span = false;            spanHasContent = false;        } else if (Q_IsColorString(p)) {            if (span && spanHasContent) {                out.Append("</span>");                span = false;                spanHasContent = false;            }            char rgb[32];            int code = ColorIndex(*++p);            Com_sprintf(rgb, sizeof(rgb), "<span style='color: #%02X%02X%02X;'>", (int) (g_color_table[code][0] * 255), (int) (g_color_table[code][1] * 255), (int) (g_color_table[code][2] * 255));            // don't add the span yet, because it might be empty            spanstr = rgb;            span = true;            spanHasContent = false;        } else {            if (span && !spanHasContent) {                out.Append(spanstr);                spanHasContent = true;            }            out.Append(*p);        }    }    if (span && spanHasContent) {        out.Append("</span>");    }    // ^^ -> ^    while (out.Find("^^") != Rocket::Core::String::npos) {        out = out.Replace("^^", "^");    }    if (parseFlags & RP_EMOTICONS) {        // Parse emoticons        size_t openBracket = 0;        size_t closeBracket = 0;        size_t currentPosition = 0;        while (1) {            Rocket::Core::String emoticon;            const char* path;            openBracket = out.Find("[", currentPosition);            if (openBracket == Rocket::Core::String::npos) {                break;            }            closeBracket = out.Find("]", openBracket);            if (closeBracket == Rocket::Core::String::npos) {                break;            }            emoticon = out.Substring(openBracket + 1, closeBracket - openBracket - 1);            // Certain characters are invalid            if (emoticon.Empty() || IsInvalidEmoticon(emoticon)) {                currentPosition = closeBracket + 1;                continue;            }            // TODO: Dont hardcode the extension.            path = va("emoticons/%s.crn", emoticon.CString());            if (FS_FOpenFileRead(path, nullptr, true)) {//.........这里部分代码省略.........

/*======================S_StartBackgroundTrack======================*/void S_StartBackgroundTrack( const char *intro, const char *loop ){	int		len;	char	dump[16];	char	name[MAX_QPATH];	if ( !intro ) {		intro = "";	}	if ( !loop || !loop[0] ) {		loop = intro;	}	Com_DPrintf( "S_StartBackgroundTrack( %s, %s )/n", intro, loop );	Q_strncpyz( name, intro, sizeof( name ) - 4 );	COM_DefaultExtension( name, sizeof( name ), ".wav" );	if ( !intro[0] ) {		return;	}	Q_strncpyz( s_backgroundLoop, loop, sizeof( s_backgroundLoop ) );	// close the background track, but DON'T reset s_rawend	// if restarting the same back ground track	if ( s_backgroundFile ) {		Sys_EndStreamedFile( s_backgroundFile );		FS_FCloseFile( s_backgroundFile );		s_backgroundFile = 0;	}	//	// open up a wav file and get all the info	//	FS_FOpenFileRead( name, &s_backgroundFile, qtrue );	if ( !s_backgroundFile ) {		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s/n", name );		return;	}	// skip the riff wav header	FS_Read(dump, 12, s_backgroundFile);	if ( !S_FindWavChunk( s_backgroundFile, "fmt " ) ) {		Com_Printf( "No fmt chunk in %s/n", name );		FS_FCloseFile( s_backgroundFile );		s_backgroundFile = 0;		return;	}	// save name for soundinfo	s_backgroundInfo.format = FGetLittleShort( s_backgroundFile );	s_backgroundInfo.channels = FGetLittleShort( s_backgroundFile );	s_backgroundInfo.rate = FGetLittleLong( s_backgroundFile );	FGetLittleLong(  s_backgroundFile );	FGetLittleShort(  s_backgroundFile );	s_backgroundInfo.width = FGetLittleShort( s_backgroundFile ) / 8;	if ( s_backgroundInfo.format != WAV_FORMAT_PCM ) {		FS_FCloseFile( s_backgroundFile );		s_backgroundFile = 0;		Com_Printf("Not a microsoft PCM format wav: %s/n", name);		return;	}	if ( s_backgroundInfo.channels != 2 || s_backgroundInfo.rate != 22050 ) {		Com_Printf(S_COLOR_YELLOW "WARNING: music file %s is not 22k stereo/n", name );	}	if ( ( len = S_FindWavChunk( s_backgroundFile, "data" ) ) == 0 ) {		FS_FCloseFile( s_backgroundFile );		s_backgroundFile = 0;		Com_Printf("No data chunk in %s/n", name);		return;	}	s_backgroundInfo.samples = len / (s_backgroundInfo.width * s_backgroundInfo.channels);	s_backgroundSamples = s_backgroundInfo.samples;	//	// start the background streaming	//	Sys_BeginStreamedFile( s_backgroundFile, 0x10000 );}