/*
* CM_LoadMapMessage
*/
char *CM_LoadMapMessage( char *name, char *message, int size )
{
int file, len;
qbyte h_v[8];
char *data, *entitystring;
lump_t l;
qboolean isworld;
char key[MAX_KEY], value[MAX_VALUE], *token;
const modelFormatDescr_t *descr;
const bspFormatDesc_t *bspFormat = NULL;
*message = '\0';
len = FS_FOpenFile( name, &file, FS_READ );
if( !file || len < 1 )
{
if( file )
FS_FCloseFile( file );
return message;
}
FS_Read( h_v, 4 + sizeof( int ), file );
descr = Com_FindFormatDescriptor( cm_supportedformats, h_v, &bspFormat );
if( !descr )
{
Com_Printf( "CM_LoadMapMessage: %s: unknown bsp format\n", name );
FS_FCloseFile( file );
return message;
}
FS_Seek( file, descr->headerLen + sizeof( int ) + sizeof( lump_t ) * bspFormat->entityLumpNum, FS_SEEK_SET );
FS_Read( &l.fileofs, sizeof( l.fileofs ), file );
l.fileofs = LittleLong( l.fileofs );
FS_Read( &l.filelen, sizeof( l.filelen ), file );
l.filelen = LittleLong( l.filelen );
if( !l.filelen )
{
FS_FCloseFile( file );
return message;
}
FS_Seek( file, l.fileofs, FS_SEEK_SET );
entitystring = Mem_TempMalloc( l.filelen );
FS_Read( entitystring, l.filelen, file );
FS_FCloseFile( file );
for( data = entitystring; ( token = COM_Parse( &data ) ) && token[0] == '{'; )
{
isworld = qtrue;
while( 1 )
{
token = COM_Parse( &data );
if( !token[0] || token[0] == '}' )
break; // end of entity
Q_strncpyz( key, token, sizeof( key ) );
while( key[strlen( key )-1] == ' ' ) // remove trailing spaces
key[strlen( key )-1] = 0;
token = COM_Parse( &data );
if( !token[0] )
break; // error
Q_strncpyz( value, token, sizeof( value ) );
// now that we have the key pair worked out...
if( !strcmp( key, "classname" ) )
{
if( strcmp( value, "worldspawn" ) )
isworld = qfalse;
}
else if( !strcmp( key, "message" ) )
{
Q_strncpyz( message, token, size );
break;
}
}
if( isworld )
break;
}
Mem_Free( entitystring );
return message;
}
static kal_bool GPSLocateNvramLoadDefault(FS_HANDLE file_handle, kal_bool newCreate)
{
int result;
unsigned int len;
GPSLocateNvramDataStruct_t tmpCache;
char default_passwd[GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN];
int i;
unsigned char* pBuff;
if (newCreate == KAL_TRUE)
{
memset(&tmpCache, 0x00, sizeof(GPSLocateNvramDataStruct_t));
}
else
{
//read from the original file
FS_Seek(file_handle, 0, FS_FILE_BEGIN);
result = FS_Read(file_handle, &tmpCache, sizeof(GPSLocateNvramDataStruct_t), &len);
if (result != FS_NO_ERROR || len != sizeof(GPSLocateNvramDataStruct_t))
{
//read fail
return KAL_FALSE;
}
}
//set version number
tmpCache.Buff[0] = GPSLOCATE_NVRAM_VER_NO;
//set default passord to all zero(ascii '0')
for (i = 0; i < GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN-1; i++)
{
default_passwd[i] = GPSLOCATE_NVRAMDATA_DEFAULT_PWD_CHAR;
}
default_passwd[GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN-1] = 0x00;
//find service password space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_SERVICEPASSWORD);
//set service password
memcpy(pBuff, default_passwd, GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN);
//find user password space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_USERPASSWORD);
//set user password one by one
for (i = 0; i < GPSLOCATE_USER_PASSWORD_MAX; i++)
{
memcpy(pBuff, default_passwd, GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN);
pBuff += GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN;
}
//find service number space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_SERVICENUMBER);
//set service number to null
memset(pBuff, 0, GPSLOCATE_PRESAVED_NUMBER_BUFFER_LEN);
//find user number space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_USERNUMBER);
//set user number to null one by one
for (i = 0; i < GPSLOCATE_USER_NUMBER_MAX; i++)
{
memset(pBuff, 0, GPSLOCATE_PRESAVED_NUMBER_BUFFER_LEN);
pBuff += GPSLOCATE_PRESAVED_NUMBER_BUFFER_LEN;
}
//find timing number space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_TIMINGNUMBER);
//set timing number to null
memset(pBuff, 0, GPSLOCATE_PRESAVED_NUMBER_BUFFER_LEN);
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_BSNUMBER)] = 1;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_SETTINGS)] = GPSLOCATE_NVRAMDATA_DEFAULT_TMSETTING;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPSONSETTING)] = 0;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_HFREEONSETTING)] = 0;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPRSUPLOADSETTING)] = 0;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_DEFENCEONSETTING)] = 0;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_MTCALLPROFILE)] = 0;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_SOSPHONECALL)] = 1;
//find gprs user space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPRSUSER);
//set service number to "PS"
strcpy((char *)pBuff, "V300Q");
//find gprs password space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPRSPASSWORD);
//set gprs password
memcpy(pBuff, default_passwd, GPSLOCATE_PRESAVED_PASSWORD_BUFFER_LEN);
//find server address space in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_SERVERADDR);
//set server address to zero
memset(pBuff, 0, sizeof(GPSLocateServerAddr_t));
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_POSMONITORONFF)] = 0;
//find fixed position in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_FIXEDPOSITION);
//set fixed position to zero
memset(pBuff, 0, sizeof(GPS_PostionRange_t));
if (newCreate == KAL_TRUE)
{
//load default value for the follwoing item only when new creating
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_BEARERMODE)] = GPSLOCATE_NVRAMDATA_DEFAULT_BEARERMODE;
}
//find gprs apn in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPRSAPN);
strcpy((char *)pBuff, "CMNET");
//find gprs apn user in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPRSAPNUSER);
memset(pBuff, 0, GPS_NVRAM_RECSIZE_GPRSAPNUSER);
//find gprs apn password in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_GPRSAPNPWD);
memset(pBuff, 0, GPS_NVRAM_RECSIZE_GPRSAPNPWD);
//find itrack front/rear msg in the data structure
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_ITRACKFRONTMSG);
strcpy((char *)pBuff, "");
pBuff = tmpCache.Buff + GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_ITRACKREARMSG);
strcpy((char *)pBuff, "");
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_VIBSENSOR_POLLINGINTERVAL)] = GPSLOCATE_VIBSENSOR_POLLINGINTERVAL_DEFAULT;
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_VIBSENSOR_SILENCETHRESHOLD)] = GPSLOCATE_VIBSENSOR_SILENCETHRESHOLD_DEFAULT;
//set end sign to 0x55('U')
tmpCache.Buff[GPSLocateNvramGetRecOffset(GPS_NVRAM_RECID_ENDSIGN)] = 0x55;
//write default data to the file
FS_Seek(file_handle, 0, FS_FILE_BEGIN);
result = FS_Write(file_handle, &tmpCache, sizeof(GPSLocateNvramDataStruct_t), &len);
if (result != FS_NO_ERROR || len != sizeof(GPSLocateNvramDataStruct_t))
{
return KAL_FALSE;
}
//load default data to the cache buffer
memcpy(&(gGPSLocateNvramDataCache.Cache), &tmpCache, sizeof(GPSLocateNvramDataStruct_t));
gGPSLocateNvramDataCache.Valid = KAL_TRUE;
return KAL_TRUE;
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args ) {
switch( args[0] ) {
case CG_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case CG_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA(1) );
return 0;
case CG_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
return 0;
case CG_ARGS:
Cmd_ArgsBuffer( VMA(1), args[2] );
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );
case CG_FS_READ:
FS_Read2( VMA(1), args[2], args[3] );
return 0;
case CG_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case CG_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] );
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA(1) );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA(1) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommand( VMA(1) );
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( VMA(1) );
return 0;
case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop
// Com_EventLoop(); // FIXME: if a server restarts here, BAD THINGS HAPPEN!
// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
// if there is a map change while we are downloading at pk3.
// ZOID
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA(1) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA(1), args[2] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA(1), args[2], VMA(3), VMA(4) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qtrue );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[1], VMA(2), VMA(3), args[4], VMA(5), args[6], VMA(7) );
case CG_S_STARTSOUND:
S_StartSound( VMA(1), args[2], args[3], args[4] );
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds(args[1]);
return 0;
case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[1] );
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], VMA(2) );
return 0;
case CG_S_RESPATIALIZE:
S_Respatialize( args[1], VMA(2), VMA(3), args[4] );
return 0;
case CG_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] );
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2) );
return 0;
case CG_R_LOADWORLDMAP:
re.LoadWorld( VMA(1) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) );
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA(1) );
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) );
case CG_R_REGISTERFONT:
re.RegisterFont( VMA(1), args[2], VMA(3));
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) );
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), args[4] );
return 0;
case CG_R_LIGHTFORPOINT:
return re.LightForPoint( VMA(1), VMA(2), VMA(3), VMA(4) );
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA(1) );
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA(1) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA(1) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA(1) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA(1), VMA(2) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], VMA(2) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], VMA(2) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], VMF(2) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[1] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
// Don't allow the cgame module to close the console
Key_SetCatcher( args[1] | ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA(1) );
case CG_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case CG_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case CG_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_SIN:
return FloatAsInt( sin( VMF(1) ) );
case CG_COS:
return FloatAsInt( cos( VMF(1) ) );
case CG_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case CG_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case CG_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case CG_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case CG_ACOS:
return FloatAsInt( Q_acos( VMF(1) ) );
case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) );
case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) );
case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) );
case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA(1) );
case CG_SNAPVECTOR:
Sys_SnapVector( VMA(1) );
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( VMA(1), VMA(2), VMA(3) );
return 0;
/*
case CG_LOADCAMERA:
return loadCamera(VMA(1));
case CG_STARTCAMERA:
startCamera(args[1]);
return 0;
case CG_GETCAMERAINFO:
return getCameraInfo(args[1], VMA(2), VMA(3));
*/
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( VMA(1), args[2] );
case CG_R_INPVS:
return re.inPVS( VMA(1), VMA(2) );
default:
assert(0);
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0] );
}
return 0;
}
/*
=================
CL_DemoReadMessage
reads demo data and write it to client
=================
*/
qboolean CL_DemoReadMessage( byte *buffer, size_t *length )
{
float f = 0.0f;
int curpos = 0;
float fElapsedTime = 0.0f;
qboolean swallowmessages = true;
byte *userbuf = NULL;
size_t size;
byte cmd;
if( !cls.demofile )
{
MsgDev( D_ERROR, "tried to read a demo message with no demo file\n" );
CL_DemoCompleted();
return false;
}
// HACKHACK: changedemo issues
if( !cls.netchan.remote_address.type )
cls.netchan.remote_address.type = NA_LOOPBACK;
if(( !cl.background && ( cl.refdef.paused || cls.key_dest != key_game )) || cls.key_dest == key_console )
{
demo.starttime += host.frametime;
return false; // paused
}
do
{
qboolean bSkipMessage = false;
if( !cls.demofile ) break;
curpos = FS_Tell( cls.demofile );
CL_ReadDemoCmdHeader( &cmd, &f );
fElapsedTime = CL_GetDemoPlaybackClock() - demo.starttime;
bSkipMessage = (f >= fElapsedTime) ? true : false;
if( cls.changelevel )
demo.framecount = 1;
// HACKHACK: changelevel issues
if( demo.framecount <= 10 && ( fElapsedTime - f ) > host.frametime )
demo.starttime = CL_GetDemoPlaybackClock();
// not ready for a message yet, put it back on the file.
if( cmd != dem_norewind && cmd != dem_stop && bSkipMessage )
{
// never skip first message
if( demo.framecount != 0 )
{
FS_Seek( cls.demofile, curpos, SEEK_SET );
return false; // not time yet.
}
}
// COMMAND HANDLERS
switch( cmd )
{
case dem_jumptime:
demo.starttime = CL_GetDemoPlaybackClock();
break;
case dem_stop:
CL_DemoMoveToNextSection();
break;
case dem_userdata:
FS_Read( cls.demofile, &size, sizeof( int ));
userbuf = Mem_Alloc( cls.mempool, size );
FS_Read( cls.demofile, userbuf, size );
if( clgame.hInstance )
clgame.dllFuncs.pfnDemo_ReadBuffer( size, userbuf );
Mem_Free( userbuf );
userbuf = NULL;
break;
case dem_usercmd:
CL_ReadDemoUserCmd( false );
break;
default:
swallowmessages = false;
break;
}
} while( swallowmessages );
if( !cls.demofile )
return false;
// if not on "LOADING" section, check a few things
if( demo.entryIndex )
{
// We are now on the second frame of a new section,
// if so, reset start time (unless in a timedemo)
if( demo.framecount == 1 )
{
// cheat by moving the relative start time forward.
demo.starttime = CL_GetDemoPlaybackClock();
}
}
demo.framecount++;
CL_ReadDemoSequence( false );
return CL_ReadRawNetworkData( buffer, length );
}
void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
FS_Seek( f, offset, origin );
}
unsigned int _GeoIP_seek_record ( unsigned long ipnum ) {
fileHandle_t file;
int depth;
unsigned int x;
unsigned char stack_buffer[2 * MAX_RECORD_LENGTH];
const unsigned char *buf = stack_buffer;
unsigned int offset = 0;
const unsigned char * p;
int j;
FS_SV_FOpenFileRead("GeoIP.dat", &file);
if(!file){
Com_Printf("File Read error.\n");
return 0;
}
/*
unsigned char *data; = malloc(1024*1024*2);
if(!FS_Seek(file, 0, SEEK_SET)){
FS_Read(data , 1024*1024*2, file);
}
*/
unsigned int foffset;
for (depth = 31; depth >= 0; depth--) {
/* read from disk */
foffset = (long)RECORD_LENGTH * 2 *offset;
if(!FS_Seek(file, foffset, FS_SEEK_SET)){
FS_Read(stack_buffer , RECORD_LENGTH * 2, file);
}
/* simply point to record in memory */
// buf = data + (long)RECORD_LENGTH * 2 *offset;
if (ipnum & (1 << depth)) {
/* Take the right-hand branch */
if ( RECORD_LENGTH == 3 ) {
/* Most common case is completely unrolled and uses constants. */
x = (buf[3*1 + 0] << (0*8)) + (buf[3*1 + 1] << (1*8)) + (buf[3*1 + 2] << (2*8));
} else {
/* General case */
j = RECORD_LENGTH;
p = &buf[2*j];
x = 0;
do {
x <<= 8;
x += *(--p);
} while ( --j );
}
} else {
/* Take the left-hand branch */
if ( RECORD_LENGTH == 3 ) {
/* Most common case is completely unrolled and uses constants. */
x = (buf[3*0 + 0] << (0*8)) + (buf[3*0 + 1] << (1*8)) + (buf[3*0 + 2] << (2*8));
} else {
/* General case */
j = RECORD_LENGTH;
p = &buf[1*j];
x = 0;
do {
x <<= 8;
x += *(--p);
} while ( --j );
}
}
if (x >= BEGIN_OFFSET) {
//gi->netmask = gl->netmask = 32 - depth;
FS_FCloseFile(file);
return x - BEGIN_OFFSET;
}
offset = x;
}
/* shouldn't reach here */
Com_PrintError("Traversing Database for ipnum = %lu - Perhaps database is corrupt?\n",ipnum);
FS_FCloseFile(file);
return 0;
}
/*
====================
CL_PlayDemo_f
playdemo <demoname>
====================
*/
void CL_PlayDemo_f( void )
{
string filename;
string demoname;
int i;
if( Cmd_Argc() != 2 )
{
Msg( "Usage: playdemo <demoname>\n" );
return;
}
if( cls.demoplayback )
{
CL_StopPlayback();
}
if( cls.demorecording )
{
Msg( "Can't playback during demo record.\n");
return;
}
Q_strncpy( demoname, Cmd_Argv( 1 ), sizeof( demoname ) - 1 );
Q_snprintf( filename, sizeof( filename ), "demos/%s.dem", demoname );
if( !FS_FileExists( filename, true ))
{
MsgDev( D_ERROR, "couldn't open %s\n", filename );
cls.demonum = -1; // stop demo loop
return;
}
cls.demofile = FS_Open( filename, "rb", true );
Q_strncpy( cls.demoname, demoname, sizeof( cls.demoname ));
Q_strncpy( menu.globals->demoname, demoname, sizeof( menu.globals->demoname ));
// read in the m_DemoHeader
FS_Read( cls.demofile, &demo.header, sizeof( demoheader_t ));
if( demo.header.id != IDEMOHEADER )
{
MsgDev( D_ERROR, "%s is not a demo file\n", filename );
FS_Close( cls.demofile );
cls.demofile = NULL;
cls.demonum = -1; // stop demo loop
return;
}
if( demo.header.net_protocol != PROTOCOL_VERSION || demo.header.dem_protocol != DEMO_PROTOCOL )
{
MsgDev( D_ERROR, "demo protocol outdated\n"
"Demo file protocols Network(%i), Demo(%i)\n"
"Server protocol is at Network(%i), Demo(%i)\n",
demo.header.net_protocol,
demo.header.dem_protocol,
PROTOCOL_VERSION,
DEMO_PROTOCOL
);
FS_Close( cls.demofile );
cls.demofile = NULL;
cls.demonum = -1; // stop demo loop
return;
}
// now read in the directory structure.
FS_Seek( cls.demofile, demo.header.directory_offset, SEEK_SET );
FS_Read( cls.demofile, &demo.directory.numentries, sizeof( int ));
if( demo.directory.numentries < 1 || demo.directory.numentries > 1024 )
{
MsgDev( D_ERROR, "demo had bogus # of directory entries: %i\n", demo.directory.numentries );
FS_Close( cls.demofile );
cls.demofile = NULL;
cls.demonum = -1; // stop demo loop
cls.changedemo = false;
return;
}
if( cls.changedemo )
{
S_StopAllSounds();
SCR_BeginLoadingPlaque( false );
CL_ClearState ();
CL_InitEdicts (); // re-arrange edicts
}
else
{
// NOTE: at this point demo is still valid
CL_Disconnect();
Host_ShutdownServer();
Con_Close();
UI_SetActiveMenu( false );
}
// allocate demo entries
demo.directory.entries = Mem_Alloc( cls.mempool, sizeof( demoentry_t ) * demo.directory.numentries );
for( i = 0; i < demo.directory.numentries; i++ )
{
FS_Read( cls.demofile, &demo.directory.entries[i], sizeof( demoentry_t ));
}
demo.entryIndex = 0;
demo.entry = &demo.directory.entries[demo.entryIndex];
FS_Seek( cls.demofile, demo.entry->offset, SEEK_SET );
cls.demoplayback = true;
cls.state = ca_connected;
cl.background = (cls.demonum != -1) ? true : false;
demo.starttime = CL_GetDemoPlaybackClock(); // for determining whether to read another message
Netchan_Setup( NS_CLIENT, &cls.netchan, net_from, net_qport->integer );
demo.framecount = 0;
cls.lastoutgoingcommand = -1;
cls.nextcmdtime = host.realtime;
// g-cont. is this need?
Q_strncpy( cls.servername, demoname, sizeof( cls.servername ));
// begin a playback demo
}
/*
====================
CL_UISystemCalls
The ui module is making a system call
====================
*/
int CL_UISystemCalls( int *args ) {
switch( args[0] ) {
case UI_ERROR:
Com_Error( ERR_DROP, "%s", VMA(1) );
return 0;
case UI_PRINT:
Com_Printf( "%s", VMA(1) );
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] );
return 0;
case UI_CVAR_UPDATE:
Cvar_Update( VMA(1) );
return 0;
case UI_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) );
return 0;
case UI_CVAR_VARIABLEVALUE:
return FloatAsInt( Cvar_VariableValue( VMA(1) ) );
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValue( VMA(1), VMF(2) );
return 0;
case UI_CVAR_RESET:
Cvar_Reset( VMA(1) );
return 0;
case UI_CVAR_CREATE:
Cvar_Get( VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], VMA(2), args[3] );
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] );
return 0;
case UI_CMD_EXECUTETEXT:
Cbuf_ExecuteText( args[1], VMA(2) );
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] );
case UI_FS_READ:
FS_Read2( VMA(1), args[2], args[3] );
return 0;
case UI_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case UI_FS_GETFILELIST:
return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] );
case UI_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] );
case UI_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) );
case UI_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) );
case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) );
case UI_R_CLEARSCENE:
re.ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) );
return 0;
case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 );
return 0;
case UI_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case UI_R_RENDERSCENE:
re.RenderScene( VMA(1) );
return 0;
case UI_R_SETCOLOR:
re.SetColor( VMA(1) );
return 0;
case UI_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0;
case UI_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) );
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) );
return 0;
case UI_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] );
case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA(2), args[3] );
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA(2), args[3] );
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding( args[1], VMA(2) );
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown( args[1] );
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[1] );
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
Key_SetCatcher( args[1] );
return 0;
case UI_GETCLIPBOARDDATA:
GetClipboardData( VMA(1), args[2] );
return 0;
case UI_GETCLIENTSTATE:
GetClientState( VMA(1) );
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig( VMA(1) );
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString( args[1], VMA(2), args[3] );
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
LAN_SaveServersToCache();
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer(args[1], VMA(2), VMA(3));
case UI_LAN_REMOVESERVER:
LAN_RemoveServer(args[1], VMA(2));
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing( args[1] );
return 0;
case UI_LAN_GETPING:
LAN_GetPing( args[1], VMA(2), args[3], VMA(4) );
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], VMA(2), args[3] );
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount(args[1]);
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], VMA(3), args[4] );
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], args[3] );
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible( args[1], args[2] );
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings( args[1] );
case UI_LAN_RESETPINGS:
LAN_ResetPings( args[1] );
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( VMA(1), VMA(2), args[3] );
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_GET_CDKEY:
CLUI_GetCDKey( VMA(1), args[2] );
return 0;
case UI_SET_CDKEY:
CLUI_SetCDKey( VMA(1) );
return 0;
case UI_SET_PBCLSTATUS:
return 0;
case UI_R_REGISTERFONT:
re.RegisterFont( VMA(1), args[2], VMA(3));
return 0;
case UI_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return 0;
case UI_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0;
case UI_STRNCPY:
return (int)strncpy( VMA(1), VMA(2), args[3] );
case UI_SIN:
return FloatAsInt( sin( VMF(1) ) );
case UI_COS:
return FloatAsInt( cos( VMF(1) ) );
case UI_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case UI_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case UI_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case UI_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) );
case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) );
case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) );
case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2));
return 0;
case UI_REAL_TIME:
return Com_RealTime( VMA(1) );
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf("UI_CIN_PlayCinematic\n");
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]);
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case UI_R_REMAP_SHADER:
re.RemapShader( VMA(1), VMA(2), VMA(3) );
return 0;
case UI_VERIFY_CDKEY:
return CL_CDKeyValidate(VMA(1), VMA(2));
default:
Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] );
}
return 0;
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args )
{
switch ( args[ 0 ] )
{
case CG_PRINT:
Com_Printf( "%s", ( char * ) VMA( 1 ) );
return 0;
case CG_ERROR:
Com_Error( ERR_DROP, "%s", ( char * ) VMA( 1 ) );
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA( 1 ) );
return 0;
case CG_CVAR_SET:
Cvar_Set( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
VM_CheckBlock( args[2], args[3], "CVARVSB" );
Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );
return 0;
case CG_CVAR_LATCHEDVARIABLESTRINGBUFFER:
VM_CheckBlock( args[2], args[3], "CVARLVSB" );
Cvar_LatchedVariableStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );
return 0;
case CG_CVAR_VARIABLEINTEGERVALUE:
return Cvar_VariableIntegerValue( VMA( 1 ) );
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
VM_CheckBlock( args[2], args[3], "ARGV" );
Cmd_ArgvBuffer( args[ 1 ], VMA( 2 ), args[ 3 ] );
return 0;
case CG_ARGS:
VM_CheckBlock( args[1], args[2], "ARGS" );
Cmd_ArgsBuffer( VMA( 1 ), args[ 2 ] );
return 0;
case CG_LITERAL_ARGS:
// FIXME
VM_CheckBlock( args[1], args[2], "LARGS" );
Cmd_LiteralArgsBuffer( VMA( 1 ), args[ 2 ] );
// Cmd_ArgsBuffer(VMA(1), args[2]);
return 0;
case CG_GETDEMOSTATE:
return CL_DemoState();
case CG_GETDEMOPOS:
return CL_DemoPos();
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[ 3 ] );
case CG_FS_READ:
VM_CheckBlock( args[1], args[2], "FSREAD" );
FS_Read2( VMA( 1 ), args[ 2 ], args[ 3 ] );
return 0;
case CG_FS_WRITE:
VM_CheckBlock( args[1], args[2], "FSWRITE" );
return FS_Write( VMA( 1 ), args[ 2 ], args[ 3 ] );
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[ 1 ] );
return 0;
case CG_FS_GETFILELIST:
VM_CheckBlock( args[3], args[4], "FSGFL" );
return FS_GetFileList( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );
case CG_FS_DELETEFILE:
return FS_Delete( VMA( 1 ) );
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA( 1 ) );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA( 1 ) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommand( VMA( 1 ) );
return 0;
case CG_COMPLETE_CALLBACK:
if ( completer )
{
completer( VMA( 1 ) );
}
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( VMA( 1 ) );
return 0;
case CG_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA( 1 ) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[ 1 ] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA( 1 ), args[ 2 ] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA( 1 ), args[ 2 ], VMA( 3 ), VMA( 4 ) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], TT_AABB );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], VMA( 8 ), VMA( 9 ), TT_AABB );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], TT_CAPSULE );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ], VMA( 8 ), VMA( 9 ), TT_CAPSULE );
return 0;
case CG_CM_BISPHERETRACE:
CM_BiSphereTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case CG_CM_TRANSFORMEDBISPHERETRACE:
CM_TransformedBiSphereTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ], VMA( 8 ) );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ], VMA( 5 ), args[ 6 ], VMA( 7 ) );
case CG_R_PROJECTDECAL:
re.ProjectDecal( args[ 1 ], args[ 2 ], VMA( 3 ), VMA( 4 ), VMA( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case CG_R_CLEARDECALS:
re.ClearDecals();
return 0;
case CG_S_STARTSOUND:
S_StartSound( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ] );
return 0;
case CG_S_STARTSOUNDEX:
S_StartSoundEx( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ] );
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[ 1 ], args[ 2 ] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds( args[ 1 ] );
return 0;
case CG_S_CLEARSOUNDS:
/*if(args[1] == 0)
{
S_ClearSounds(qtrue, qfalse);
}
else if(args[1] == 1)
{
S_ClearSounds(qtrue, qtrue);
}*/
return 0;
case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[ 1 ] );
return 0;
case CG_S_STOPSTREAMINGSOUND:
// FIXME
//S_StopEntStreamingSound(args[1]);
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[ 1 ], VMA( 2 ) );
return 0;
case CG_S_GETVOICEAMPLITUDE:
return S_GetVoiceAmplitude( args[ 1 ] );
case CG_S_GETSOUNDLENGTH:
return S_GetSoundLength( args[ 1 ] );
// ydnar: for looped sound starts
case CG_S_GETCURRENTSOUNDTIME:
return S_GetCurrentSoundTime();
case CG_S_RESPATIALIZE:
S_Respatialize( args[ 1 ], VMA( 2 ), VMA( 3 ), args[ 4 ] );
return 0;
case CG_S_REGISTERSOUND:
#ifdef DOOMSOUND ///// (SA) DOOMSOUND
return S_RegisterSound( VMA( 1 ) );
#else
return S_RegisterSound( VMA( 1 ), args[ 2 ] );
#endif ///// (SA) DOOMSOUND
case CG_S_STARTBACKGROUNDTRACK:
//S_StartBackgroundTrack(VMA(1), VMA(2), args[3]); //----(SA) added fadeup time
S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_S_FADESTREAMINGSOUND:
// FIXME
//S_FadeStreamingSound(VMF(1), args[2], args[3]); //----(SA) added music/all-streaming options
return 0;
case CG_S_STARTSTREAMINGSOUND:
// FIXME
//return S_StartStreamingSound(VMA(1), VMA(2), args[3], args[4], args[5]);
return 0;
case CG_R_LOADWORLDMAP:
re.SetWorldVisData( CM_ClusterPVS( -1 ) );
re.LoadWorld( VMA( 1 ) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA( 1 ) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA( 1 ) );
//----(SA) added
case CG_R_GETSKINMODEL:
return re.GetSkinModel( args[ 1 ], VMA( 2 ), VMA( 3 ) );
case CG_R_GETMODELSHADER:
return re.GetShaderFromModel( args[ 1 ], args[ 2 ], args[ 3 ] );
//----(SA) end
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA( 1 ) );
case CG_R_REGISTERFONT:
re.RegisterFontVM( VMA( 1 ), VMA( 2 ), args[ 3 ], VMA( 4 ) );
return 0;
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA( 1 ) );
#if defined( USE_REFLIGHT )
case CG_R_REGISTERSHADERLIGHTATTENUATION:
return re.RegisterShaderLightAttenuation( VMA( 1 ) );
#endif
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA( 1 ) );
return 0;
#if defined( USE_REFLIGHT )
case CG_R_ADDREFLIGHTSTOSCENE:
re.AddRefLightToScene( VMA( 1 ) );
return 0;
#endif
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[ 1 ], args[ 2 ], VMA( 3 ) );
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolysToScene( args[ 1 ], args[ 2 ], VMA( 3 ), args[ 4 ] );
return 0;
case CG_R_ADDPOLYBUFFERTOSCENE:
re.AddPolyBufferToScene( VMA( 1 ) );
return 0;
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), args[ 7 ], args[ 8 ] );
return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ) );
return 0;
case CG_FS_SEEK:
return FS_Seek( args[ 1 ], args[ 2 ], args[ 3 ] );
case CG_R_ADDCORONATOSCENE:
re.AddCoronaToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case CG_R_SETFOG:
re.SetFog( args[ 1 ], args[ 2 ], args[ 3 ], VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ) );
return 0;
case CG_R_SETGLOBALFOG:
re.SetGlobalFog( args[ 1 ], args[ 2 ], VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA( 1 ) );
return 0;
case CG_R_SAVEVIEWPARMS:
re.SaveViewParms();
return 0;
case CG_R_RESTOREVIEWPARMS:
re.RestoreViewParms();
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA( 1 ) );
return 0;
// Tremulous
case CG_R_SETCLIPREGION:
re.SetClipRegion( VMA( 1 ) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ] );
return 0;
case CG_R_DRAWROTATEDPIC:
re.DrawRotatedPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ], VMF( 10 ) );
return 0;
case CG_R_DRAWSTRETCHPIC_GRADIENT:
re.DrawStretchPicGradient( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ], VMA( 10 ), args[ 11 ] );
return 0;
case CG_R_DRAW2DPOLYS:
re.Add2dPolys( VMA( 1 ), args[ 2 ], args[ 3 ] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[ 1 ], VMA( 2 ), VMA( 3 ) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[ 4 ] );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA( 1 ) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA( 1 ) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[ 1 ], VMA( 2 ) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[ 1 ] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[ 1 ], VMA( 2 ) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[ 1 ], args[ 2 ], VMF( 3 ), args[ 4 ] );
return 0;
case CG_SETCLIENTLERPORIGIN:
CL_SetClientLerpOrigin( VMF( 1 ), VMF( 2 ), VMF( 3 ) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[ 1 ] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
Key_SetCatcher( args[ 1 ] );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA( 1 ) );
case CG_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case CG_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[ 1 ] );
return 0;
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA( 1 ) );
case CG_SNAPVECTOR:
Q_SnapVector( VMA( 1 ) );
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ], args[ 6 ] );
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[ 1 ] );
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[ 1 ] );
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[ 1 ] );
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents( args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ] );
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case CG_GET_ENTITY_TOKEN:
VM_CheckBlock( args[1], args[2], "GETET" );
return re.GetEntityToken( VMA( 1 ), args[ 2 ] );
case CG_INGAME_POPUP:
if ( cls.state == CA_ACTIVE && !clc.demoplaying )
{
if ( uivm )
{
// Gordon: can be called as the system is shutting down
VM_Call( uivm, UI_SET_ACTIVE_MENU, args[ 1 ] );
}
}
return 0;
case CG_INGAME_CLOSEPOPUP:
return 0;
case CG_KEY_GETBINDINGBUF:
VM_CheckBlock( args[2], args[3], "KEYGBB" );
Key_GetBindingBuf( args[ 1 ], VMA( 2 ), args[ 3 ] );
return 0;
case CG_KEY_SETBINDING:
Key_SetBinding( args[ 1 ], VMA( 2 ) );
return 0;
case CG_PARSE_ADD_GLOBAL_DEFINE:
return Parse_AddGlobalDefine( VMA( 1 ) );
case CG_PARSE_LOAD_SOURCE:
return Parse_LoadSourceHandle( VMA( 1 ) );
case CG_PARSE_FREE_SOURCE:
return Parse_FreeSourceHandle( args[ 1 ] );
case CG_PARSE_READ_TOKEN:
return Parse_ReadTokenHandle( args[ 1 ], VMA( 2 ) );
case CG_PARSE_SOURCE_FILE_AND_LINE:
return Parse_SourceFileAndLine( args[ 1 ], VMA( 2 ), VMA( 3 ) );
case CG_KEY_KEYNUMTOSTRINGBUF:
VM_CheckBlock( args[2], args[3], "KEYNTSB" );
Key_KeynumToStringBuf( args[ 1 ], VMA( 2 ), args[ 3 ] );
return 0;
case CG_KEY_BINDINGTOKEYS:
Key_GetBindingByString( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case CG_S_FADEALLSOUNDS:
// FIXME
//S_FadeAllSounds(VMF(1), args[2], args[3]);
return 0;
case CG_R_INPVS:
return re.inPVS( VMA( 1 ), VMA( 2 ) );
case CG_GETHUNKDATA:
Com_GetHunkInfo( VMA( 1 ), VMA( 2 ) );
return 0;
//bani - dynamic shaders
case CG_R_LOADDYNAMICSHADER:
return re.LoadDynamicShader( VMA( 1 ), VMA( 2 ) );
// fretn - render to texture
case CG_R_RENDERTOTEXTURE:
re.RenderToTexture( args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ] );
return 0;
//bani
case CG_R_GETTEXTUREID:
return re.GetTextureId( VMA( 1 ) );
//bani - flush gl rendering buffers
case CG_R_FINISH:
re.Finish();
return 0;
case CG_GETDEMONAME:
VM_CheckBlock( args[1], args[2], "GETDM" );
CL_DemoName( VMA( 1 ), args[ 2 ] );
return 0;
case CG_R_LIGHTFORPOINT:
return re.LightForPoint( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ) );
case CG_S_SOUNDDURATION:
return S_SoundDuration( args[ 1 ] );
#if defined( USE_REFENTITY_ANIMATIONSYSTEM )
case CG_R_REGISTERANIMATION:
return re.RegisterAnimation( VMA( 1 ) );
case CG_R_CHECKSKELETON:
return re.CheckSkeleton( VMA( 1 ), args[ 2 ], args[ 3 ] );
case CG_R_BUILDSKELETON:
return re.BuildSkeleton( VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], VMF( 5 ), args[ 6 ] );
case CG_R_BLENDSKELETON:
return re.BlendSkeleton( VMA( 1 ), VMA( 2 ), VMF( 3 ) );
case CG_R_BONEINDEX:
return re.BoneIndex( args[ 1 ], VMA( 2 ) );
case CG_R_ANIMNUMFRAMES:
return re.AnimNumFrames( args[ 1 ] );
case CG_R_ANIMFRAMERATE:
return re.AnimFrameRate( args[ 1 ] );
#endif
case CG_REGISTER_BUTTON_COMMANDS:
CL_RegisterButtonCommands( VMA( 1 ) );
return 0;
case CG_GETCLIPBOARDDATA:
VM_CheckBlock( args[1], args[2], "GETCLIP" );
if ( cl_allowPaste->integer )
{
CL_GetClipboardData( VMA(1), args[2], args[3] );
}
else
{
( (char *) VMA( 1 ) )[0] = '\0';
}
return 0;
case CG_QUOTESTRING:
Cmd_QuoteStringBuffer( VMA( 1 ), VMA( 2 ), args[ 3 ] );
return 0;
case CG_GETTEXT:
strncpy( VMA(1), __(VMA(2)), args[3] );
return 0;
case CG_PGETTEXT:
strncpy( VMA( 1 ), C__( VMA( 2 ), VMA( 3 ) ), args[ 4 ] );
return 0;
case CG_R_GLYPH:
re.GlyphVM( args[1], VMA(2), VMA(3) );
return 0;
case CG_R_GLYPHCHAR:
re.GlyphCharVM( args[1], args[2], VMA(3) );
return 0;
case CG_R_UREGISTERFONT:
re.UnregisterFontVM( args[1] );
return 0;
default:
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", ( long int ) args[ 0 ] );
}
return 0;
}
// Do very shallow parse of the demo (could be extended) just to get times and snapshot count
static void CL_ParseDemo(void)
{
int tstart = 0;
int demofile = 0;
// Reset our demo data
memset(&di, 0, sizeof(di));
// Parse start
di.gameStartTime = -1;
di.gameEndTime = -1;
FS_Seek(clc.demofile, 0, FS_SEEK_SET);
tstart = Sys_Milliseconds();
while (qtrue)
{
int r;
msg_t buf;
msg_t *msg;
byte bufData[MAX_MSGLEN];
int s;
int cmd;
di.demoPos = FS_FTell(clc.demofile);
// get the sequence number
r = FS_Read(&s, 4, clc.demofile);
if (r != 4)
{
CL_DemoCompleted();
return;
}
clc.serverMessageSequence = LittleLong(s);
// init the message
MSG_Init(&buf, bufData, sizeof(bufData));
// get the length
r = FS_Read(&buf.cursize, 4, clc.demofile);
if (r != 4)
{
break;
}
buf.cursize = LittleLong(buf.cursize);
if (buf.cursize == -1)
{
break;
}
if (buf.cursize > buf.maxsize)
{
Com_FuncPrinf("demoMsglen > MAX_MSGLEN");
break;
}
r = FS_Read(buf.data, buf.cursize, clc.demofile);
if (r != buf.cursize)
{
Com_FuncPrinf("Demo file was truncated.\n");
break;
}
clc.lastPacketTime = cls.realtime;
buf.readcount = 0;
// parse
msg = &buf;
MSG_Bitstream(msg);
// get the reliable sequence acknowledge number
clc.reliableAcknowledge = MSG_ReadLong(msg);
if (clc.reliableAcknowledge < clc.reliableSequence - MAX_RELIABLE_COMMANDS)
{
clc.reliableAcknowledge = clc.reliableSequence;
}
// parse the message
while (qtrue)
{
if (msg->readcount > msg->cursize)
{
Com_FuncDrop("read past end of server message");
return;
}
cmd = MSG_ReadByte(msg);
if (cmd == svc_EOF)
{
break;
}
// other commands
switch (cmd)
{
default:
Com_FuncDrop("Illegible server message %d", cmd);
return;
case svc_nop:
break;
case svc_serverCommand:
MSG_ReadLong(msg);
MSG_ReadString(msg);
break;
case svc_gamestate:
clc.serverCommandSequence = MSG_ReadLong(msg);
cl.gameState.dataCount = 1;
while (qtrue)
{
int cmd2 = MSG_ReadByte(msg);
if (cmd2 == svc_EOF)
{
break;
}
if (cmd2 == svc_configstring)
{
MSG_ReadShort(msg);
MSG_ReadBigString(msg);
}
else if (cmd2 == svc_baseline)
{
entityState_t s1, s2;
memset(&s1, 0, sizeof(s1));
memset(&s2, 0, sizeof(s2));
MSG_ReadBits(msg, GENTITYNUM_BITS);
MSG_ReadDeltaEntity(msg, &s1, &s2, 0);
}
else
{
Com_FuncDrop("bad command byte");
return;
}
}
MSG_ReadLong(msg);
MSG_ReadLong(msg);
break;
case svc_snapshot:
CL_ParseDemoSnapShotSimple(msg);
break;
case svc_download:
MSG_ReadShort(msg);
break;
}
}
if (!cl.snap.valid)
{
Com_FuncPrinf("!cl.snap.valid\n");
continue;
}
if (cl.snap.serverTime < cl.oldFrameServerTime)
{
// ignore snapshots that don't have entities
if (cl.snap.snapFlags & SNAPFLAG_NOT_ACTIVE)
{
continue;
}
cls.state = CA_ACTIVE;
// set the timedelta so we are exactly on this first frame
cl.serverTimeDelta = cl.snap.serverTime - cls.realtime;
cl.oldServerTime = cl.snap.serverTime;
clc.timeDemoBaseTime = cl.snap.serverTime;
}
cl.oldFrameServerTime = cl.snap.serverTime;
if (cl.newSnapshots)
{
CL_AdjustTimeDelta();
}
di.lastServerTime = cl.snap.serverTime;
if (di.firstServerTime == 0)
{
di.firstServerTime = cl.snap.serverTime;
Com_FuncPrinf("firstServerTime %d\n", di.firstServerTime);
}
di.snapsInDemo++;
}
Com_FuncPrinf("Snaps in demo: %i\n", di.snapsInDemo);
Com_FuncPrinf("last serverTime %d total %f minutes\n", cl.snap.serverTime, (cl.snap.serverTime - di.firstServerTime) / 1000.0 / 60.0);
Com_FuncPrinf("parse time %f seconds\n", (float)(Sys_Milliseconds() - tstart) / 1000.0);
FS_Seek(clc.demofile, 0, FS_SEEK_SET);
clc.demoplaying = qfalse;
demofile = clc.demofile;
CL_ClearState();
Com_Memset(&clc, 0, sizeof(clc));
Com_ClearDownload();
clc.demofile = demofile;
cls.state = CA_DISCONNECTED;
cl_connectedToPureServer = qfalse;
dpi.firstTime = di.firstServerTime;
dpi.lastTime = di.lastServerTime;
}
bool
Md3Utils::getModelDimensions( fileHandle_t const& file,
vec3_t& mins,
vec3_t& maxs,
int checkFrame )
{
if( !file )
{
Com_Error(ERR_FATAL, "Invalid filehandle passed to Md3Utils::getModelDimensions\n" );
return false;
}
// put it back to beginning of file (just in case)
if( FS_Seek( file, 0, FS_SEEK_SET ) != 0 )
{
Com_Error(ERR_FATAL, "Unable to set file pointer in file!\n" );
return false;
}
bool found = false;
// get body bounding boxes
md3Header_t header;
md3Frame_t currentFrame;
FS_Read2(&header, sizeof(header), file);
int number = header.numFrames;
if( checkFrame >= number )
{
Com_Error(ERR_FATAL, "File only has %d frames, therefore unable to check frame %d\n",
number, checkFrame );
return false;
}
else if( checkFrame == FRAMESIZE_FIRST )
checkFrame = 0;
else if( checkFrame == FRAMESIZE_LAST )
checkFrame = number - 1;
found = true;
for( int i = 0; i < number; ++i )
{
FS_Read2(¤tFrame, sizeof(currentFrame), file);
if( checkFrame >= 0 && i == checkFrame )
{
VectorCopy( currentFrame.bounds[0], mins );
VectorCopy( currentFrame.bounds[1], maxs );
break;
}
else // check for all
{
if( i == 0 )
{
VectorCopy( currentFrame.bounds[0], mins );
VectorCopy( currentFrame.bounds[1], maxs );
}
else
{
if( currentFrame.bounds[0][0] < mins[0] )
mins[0] = currentFrame.bounds[0][0];
if( currentFrame.bounds[0][1] < mins[1] )
mins[1] = currentFrame.bounds[0][1];
if( currentFrame.bounds[0][2] < mins[2] )
mins[2] = currentFrame.bounds[0][2];
if( currentFrame.bounds[1][0] > maxs[0] )
maxs[0] = currentFrame.bounds[1][0];
if( currentFrame.bounds[1][1] > maxs[1] )
maxs[1] = currentFrame.bounds[1][1];
if( currentFrame.bounds[1][2] > maxs[2] )
maxs[2] = currentFrame.bounds[1][2];
}
}
}
return found;
}
qboolean CL_PeekSnapshot(int snapshotNumber, snapshot_t *snapshot)
{
clSnapshot_t *clSnap;
clSnapshot_t csn;
int i, count;
int origPosition;
int cmd;
//char *s;
char buffer[16];
qboolean success = qfalse;
int r;
msg_t buf;
byte bufData[MAX_MSGLEN];
int j;
int lastPacketTimeOrig;
int parseEntitiesNumOrig;
int currentSnapNum;
//int serverMessageSequence;
clSnap = &csn;
if (!clc.demoplaying)
{
return qfalse;
}
if (snapshotNumber <= cl.snap.messageNum)
{
success = CL_GetSnapshot(snapshotNumber, snapshot);
if (!success)
{
Com_FuncPrinf("snapshot number outside of backup buffer\n");
return qfalse;
}
return qtrue;
}
if (snapshotNumber > cl.snap.messageNum + 1)
{
Com_FuncPrinf("FIXME CL_PeekSnapshot %d > cl.snap.messageNum + 1 (%d)\n", snapshotNumber, cl.snap.messageNum);
return qfalse; // FIXME:
}
parseEntitiesNumOrig = cl.parseEntitiesNum;
lastPacketTimeOrig = clc.lastPacketTime;
// CL_ReadDemoMessage()
origPosition = FS_FTell(clc.demofile);
if (origPosition < 0)
{
// FS_FTell prints the warning ...
return qfalse;
}
currentSnapNum = cl.snap.messageNum;
for (j = 0; j < snapshotNumber - currentSnapNum; j++)
{
// get the sequence number
memset(buffer, 0, sizeof(buffer));
r = FS_Read(&buffer, 4, clc.demofile);
if (r != 4)
{
Com_FuncPrinf("couldn't read sequence number\n");
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
return qfalse;
}
//serverMessageSequence = LittleLong(*((int *)buffer));
// init the message
memset(&buf, 0, sizeof(msg_t));
MSG_Init(&buf, bufData, sizeof(bufData));
// get the length
r = FS_Read(&buf.cursize, 4, clc.demofile);
if (r != 4)
{
Com_FuncPrinf("couldn't get length\n");
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
return qfalse;
}
buf.cursize = LittleLong(buf.cursize);
if (buf.cursize == -1)
{
Com_FuncPrinf("buf.cursize == -1\n");
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
return qfalse;
}
if (buf.cursize > buf.maxsize)
{
Com_FuncDrop("demoMsglen > MAX_MSGLEN");
return qfalse;
}
r = FS_Read(buf.data, buf.cursize, clc.demofile);
if (r != buf.cursize)
{
Com_FuncPrinf("Demo file was truncated.\n");
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
return qfalse;
}
clc.lastPacketTime = cls.realtime;
buf.readcount = 0;
MSG_Bitstream(&buf);
// get the reliable sequence acknowledge number
MSG_ReadLong(&buf);
// parse the message
while (qtrue)
{
if (buf.readcount > buf.cursize)
{
Com_FuncDrop("read past end of server message");
return qfalse;
}
cmd = MSG_ReadByte(&buf);
if (cmd == svc_EOF)
{
break;
}
success = qfalse;
switch (cmd)
{
default:
Com_FuncDrop("Illegible server message");
return qfalse;
case svc_nop:
break;
case svc_serverCommand:
MSG_ReadLong(&buf); // seq
//s = MSG_ReadString(&buf);
MSG_ReadString(&buf);
break;
case svc_gamestate:
Com_FuncPrinf("FIXME gamestate\n");
goto alldone;
break;
case svc_snapshot:
// TODO: changed this check if it works
CL_ParseSnapshot(&buf);
if (cl.snap.valid)
{
success = qtrue;
}
break;
case svc_download:
Com_FuncPrinf("FIXME download\n");
goto alldone;
break;
}
}
alldone:
if (!success)
{
Com_FuncPrinf("failed\n");
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
return success;
}
// FIXME other ents not supported yet
// if the entities in the frame have fallen out of their
// circular buffer, we can't return it
if (cl.parseEntitiesNum - clSnap->parseEntitiesNum >= MAX_PARSE_ENTITIES)
{
Com_FuncPrinf("cl.parseEntitiesNum - clSnap->parseEntitiesNum >= MAX_PARSE_ENTITIES");
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
return qtrue; // FIXME if you fix other ents
}
// write the snapshot
snapshot->snapFlags = clSnap->snapFlags;
snapshot->serverCommandSequence = clSnap->serverCommandNum;
snapshot->ping = clSnap->ping;
snapshot->serverTime = clSnap->serverTime;
Com_Memcpy(snapshot->areamask, clSnap->areamask, sizeof(snapshot->areamask));
snapshot->ps = clSnap->ps;
count = clSnap->numEntities;
if (count > MAX_ENTITIES_IN_SNAPSHOT)
{
Com_FuncPrinf("truncated %i entities to %i\n", count, MAX_ENTITIES_IN_SNAPSHOT);
count = MAX_ENTITIES_IN_SNAPSHOT;
}
snapshot->numEntities = count;
for (i = 0; i < count; i++)
{
snapshot->entities[i] = cl.parseEntities[(clSnap->parseEntitiesNum + i) & (MAX_PARSE_ENTITIES - 1)];
}
}
FS_Seek(clc.demofile, origPosition, FS_SEEK_SET);
clc.lastPacketTime = lastPacketTimeOrig;
cl.parseEntitiesNum = parseEntitiesNumOrig;
// TODO: configstring changes and server commands!!!
return qtrue;
}
/*
====================
CL_ReadDemoMessage
Handles playback of demos
====================
*/
void CL_ReadDemoMessage(void)
{
int i;
float f;
if (!cls.demoplayback)
return;
// LordHavoc: pausedemo
if (cls.demopaused)
return;
for (;;)
{
// decide if it is time to grab the next message
// always grab until fully connected
if (cls.signon == SIGNONS)
{
if (cls.timedemo)
{
cls.td_frames++;
cls.td_onesecondframes++;
// if this is the first official frame we can now grab the real
// td_starttime so the bogus time on the first frame doesn't
// count against the final report
if (cls.td_frames == 0)
{
cls.td_starttime = realtime;
cls.td_onesecondnexttime = cl.time + 1;
cls.td_onesecondrealtime = realtime;
cls.td_onesecondframes = 0;
cls.td_onesecondminfps = 0;
cls.td_onesecondmaxfps = 0;
cls.td_onesecondavgfps = 0;
cls.td_onesecondavgcount = 0;
}
if (cl.time >= cls.td_onesecondnexttime)
{
double fps = cls.td_onesecondframes / (realtime - cls.td_onesecondrealtime);
if (cls.td_onesecondavgcount == 0)
{
cls.td_onesecondminfps = fps;
cls.td_onesecondmaxfps = fps;
}
cls.td_onesecondrealtime = realtime;
cls.td_onesecondminfps = min(cls.td_onesecondminfps, fps);
cls.td_onesecondmaxfps = max(cls.td_onesecondmaxfps, fps);
cls.td_onesecondavgfps += fps;
cls.td_onesecondavgcount++;
cls.td_onesecondframes = 0;
cls.td_onesecondnexttime++;
}
}
else if (cl.time <= cl.mtime[0])
{
// don't need another message yet
return;
}
}
// get the next message
FS_Read(cls.demofile, &cl_message.cursize, 4);
cl_message.cursize = LittleLong(cl_message.cursize);
if(cl_message.cursize & DEMOMSG_CLIENT_TO_SERVER) // This is a client->server message! Ignore for now!
{
// skip over demo packet
FS_Seek(cls.demofile, 12 + (cl_message.cursize & (~DEMOMSG_CLIENT_TO_SERVER)), SEEK_CUR);
continue;
}
if (cl_message.cursize > cl_message.maxsize)
{
Con_Printf("Demo message (%i) > cl_message.maxsize (%i)", cl_message.cursize, cl_message.maxsize);
cl_message.cursize = 0;
CL_Disconnect();
return;
}
VectorCopy(cl.mviewangles[0], cl.mviewangles[1]);
for (i = 0;i < 3;i++)
{
FS_Read(cls.demofile, &f, 4);
cl.mviewangles[0][i] = LittleFloat(f);
}
if (FS_Read(cls.demofile, cl_message.data, cl_message.cursize) == cl_message.cursize)
{
MSG_BeginReading(&cl_message);
CL_ParseServerMessage();
if (cls.signon != SIGNONS)
Cbuf_Execute(); // immediately execute svc_stufftext if in the demo before connect!
// In case the demo contains a "svc_disconnect" message
if (!cls.demoplayback)
return;
if (cls.timedemo)
return;
}
else
{
CL_Disconnect();
return;
}
}
}
/*****************************************************************************
* FUNCTION
* aud_trim_open_req_hdlr
* DESCRIPTION
* This function is used to open a trimming handler.
* PARAMETERS
*
* RETURNS
* void
*****************************************************************************/
void aud_trim_open_req_hdlr(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint32 file_len = 0;
FSAL_Status fsal_result;
kal_uint8* fsal_buf_p = NULL;
media_open_func_ptr open_fct = NULL;
kal_int32 result = MED_RES_FAIL;
l4aud_trim_open_req_struct* msg_p = (l4aud_trim_open_req_struct*) ilm_ptr->local_para_ptr;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
ASSERT(msg_p->file_name_in && msg_p->file_name_out && msg_p->handle_p);
/* Check if trimming handler is already opened. Currently, we only support one instance. */
if (g_is_trim_opened)
{
result = MED_RES_BUSY;
goto aud_trim_open_failed;
}
/* Initialize context */
g_is_trim_opened = KAL_TRUE;
memset(&g_trim_ctx, 0, sizeof(aud_trim_context_t));
g_trim_ctx.file_output = -1;
g_trim_ctx.src_mod_id = ilm_ptr->src_mod_id;
/* Select a MHdl open function per media format */
g_trim_ctx.format = med_get_media_type(msg_p->file_name_in);
switch (g_trim_ctx.format)
{
#ifdef DAF_DECODE
case MED_TYPE_DAF:
#endif /* DAF_DECODE */
open_fct = DAF_Open;
break;
default:
/* Unsupport format */
ASSERT(0);
}
if (open_fct)
{
/* Create a FSAL handler */
if ((fsal_result = FSAL_Open(&g_trim_ctx.fsal_handle, msg_p->file_name_in, FSAL_READ_SHARED)) != FSAL_OK)
{
result = MED_RES_OPEN_FILE_FAIL;
goto aud_trim_open_failed;
}
g_trim_ctx.is_fsal_opened = KAL_TRUE;
fsal_buf_p = (kal_uint8*) get_ctrl_buffer(sizeof(kal_uint8) * AUD_PROC_BUF_SIZE);
FSAL_SetBuffer(&g_trim_ctx.fsal_handle, AUD_PROC_BUF_SIZE, fsal_buf_p);
/* Open a MHdl handler */
g_trim_ctx.mhdl_handle_p = open_fct(_aud_trim_event_callback_fct, &g_trim_ctx.fsal_handle, NULL);
_AUD_TRIM_TRACE(g_trim_ctx.mhdl_handle_p, g_trim_ctx.format, fsal_buf_p);
if (g_trim_ctx.mhdl_handle_p == NULL)
{
result = MED_RES_BAD_FORMAT;
goto aud_trim_open_failed;
}
/* Create output file handle */
g_trim_ctx.file_output = FS_Open(msg_p->file_name_out, FS_READ_WRITE | FS_OPEN_SHARED | FS_NOBUSY_CHECK_MODE);
if (g_trim_ctx.file_output >= 0) /* File already exists */
{
/* Check if the size of file is 0 because MMI may create the file to be trimmed to in advance */
FS_GetFileSize(g_trim_ctx.file_output, &file_len);
if (file_len != 0)
{
/* Seek to the beginning of the file to overwrite all the data */
FS_Seek(g_trim_ctx.file_output, 0, FS_FILE_BEGIN);
}
}
else /* File does not exist */
{
/* Create a new file */
g_trim_ctx.file_output = FS_Open(msg_p->file_name_out, FS_CREATE | FS_READ_WRITE | FS_OPEN_SHARED | FS_NOBUSY_CHECK_MODE);
}
_AUD_TRIM_TRACE(g_trim_ctx.file_output, file_len, -1);
if (g_trim_ctx.file_output < 0)
{
result = MED_RES_OPEN_FILE_FAIL;
goto aud_trim_open_failed;
}
}
/* Open successful */
*msg_p->handle_p = (kal_uint32)g_trim_ctx.mhdl_handle_p;
AUD_TRIM_RETURN(MED_RES_OK);
return;
aud_trim_open_failed:
/* Open failed */
_aud_trim_close();
*msg_p->handle_p = (kal_uint32)0;
AUD_TRIM_RETURN(result);
}
void HPAK_RemoveLump( const char *name, resource_t *resource )
{
string read_path;
string save_path;
file_t *f1, *f2;
hpak_container_t hpak_read;
hpak_container_t hpak_save;
int i, j;
if( !name || !name[0] || !resource )
return;
HPAK_FlushHostQueue();
Q_strncpy( read_path, name, sizeof( read_path ));
FS_StripExtension( read_path );
FS_DefaultExtension( read_path, ".hpk" );
f1 = FS_Open( read_path, "rb", false );
if( !f1 )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s couldn't open.\n", read_path );
return;
}
Q_strncpy( save_path, read_path, sizeof( save_path ));
FS_StripExtension( save_path );
FS_DefaultExtension( save_path, ".hp2" );
f2 = FS_Open( save_path, "w+b", false );
if( !f2 )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s couldn't open.\n", save_path );
FS_Close( f1 );
return;
}
FS_Seek( f1, 0, SEEK_SET );
FS_Seek( f2, 0, SEEK_SET );
// header copy
FS_Read( f1, &hash_pack_header, sizeof( hpak_header_t ));
FS_Write( f2, &hash_pack_header, sizeof( hpak_header_t ));
if( hash_pack_header.ident != IDCUSTOMHEADER || hash_pack_header.version != IDCUSTOM_VERSION )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s has invalid header.\n", read_path );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( save_path ); // delete temp file
return;
}
FS_Seek( f1, hash_pack_header.seek, SEEK_SET );
FS_Read( f1, &hpak_read.count, sizeof( hpak_read.count ));
if( hpak_read.count < 1 || hpak_read.count > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s has invalid number of lumps.\n", read_path );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( save_path ); // delete temp file
return;
}
if( hpak_read.count == 1 )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s only has one element, so it's not deleted.\n", read_path );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( read_path );
FS_Delete( save_path );
return;
}
hpak_save.count = hpak_read.count - 1;
hpak_read.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak_read.count );
hpak_save.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak_save.count );
FS_Read( f1, hpak_read.dirs, sizeof( hpak_dir_t ) * hpak_read.count );
if( !HPAK_FindResource( &hpak_read, resource->rgucMD5_hash, NULL ))
{
MsgDev( D_ERROR, "HPAK_RemoveLump: Couldn't find the lump %s in hpak %s.n", resource->szFileName, read_path );
Mem_Free( hpak_read.dirs );
Mem_Free( hpak_save.dirs );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( save_path );
return;
}
MsgDev( D_INFO, "Removing lump %s from %s.\n", resource->szFileName, read_path );
// If there's a collision, we've just corrupted this hpak.
for( i = 0, j = 0; i < hpak_read.count; i++ )
{
if( !Q_memcmp( hpak_read.dirs[i].DirectoryResource.rgucMD5_hash, resource->rgucMD5_hash, 16 ))
continue;
hpak_save.dirs[j] = hpak_read.dirs[i];
hpak_save.dirs[j].seek = FS_Tell( f2 );
FS_Seek( f1, hpak_read.dirs[j].seek, SEEK_SET );
HPAK_FileCopy( f2, f1, hpak_save.dirs[j].size );
j++;
}
hash_pack_header.seek = FS_Tell( f2 );
FS_Write( f2, &hpak_save.count, ( hpak_save.count ));
for( i = 0; i < hpak_save.count; i++ )
{
FS_Write( f2, &hpak_save.dirs[i], sizeof( hpak_dir_t ));
}
FS_Seek( f2, 0, SEEK_SET );
FS_Write( f2, &hash_pack_header, sizeof( hpak_header_t ));
Mem_Free( hpak_read.dirs );
Mem_Free( hpak_save.dirs );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( read_path );
FS_Rename( save_path, read_path );
}
/*****************************************************************************
* FUNCTION
* btmtk_fs_open
* DESCRIPTION
*
* PARAMETERS
* fileName [IN]
* mode [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_open(const U8 *fileName, U32 mode)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
int i;
#ifdef BTMTK_ON_WISE
int err, err1;
#else
FILE *fp;
U8 fileExist = 0;
#endif
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
for (i = 0; i < BT_MAX_NUM_FILES; i++)
{
if (bt_file_desc[i].used == KAL_FALSE)
{
break;
}
}
if (i >= BT_MAX_NUM_FILES)
{
return BTMTK_FS_ERR_FULL;
}
#ifdef BTMTK_ON_WISE
bt_asc_str_n_to_ucs2_str((S8 *)pathBuf, (S8 *)fileName, FS_MAX_PATH_LEN * sizeof(U16));
err = FS_Open(pathBuf, translateFileMode(mode));
if ((mode & BTMTK_FS_APPEND) && err >= 0)
{
err1 = FS_Seek(err, 0, FS_FILE_END);
err = (err1 < 0) ? err1 : err;
}
if (err >= 0)
{
bt_file_desc[i] = err;
bt_file_desc[i].used = KAL_TRUE;
return i;
}
else
{
return translateFileError(err);
}
#else /* BTMTK_ON_WISE */
bt_prompt_trace(MOD_BT, "[FS] +btmtk_fs_open(fileName=%s, mode=0x%X)", fileName, mode);
translateFilePath(fileName, (U8 *)pathBuf);
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_open: %s", fileName);
fileExist = IsFileExist((const char *)pathBuf);
fp = fopen((char *)pathBuf, translateFileModeC(mode));
if (fp == NULL)
{
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_open failed : %s, errno=%d", strerror(errno), errno);
return BTMTK_FS_ERR;
}
else
{
bt_file_desc[i].handle = (int)fp;
bt_file_desc[i].used = KAL_TRUE;
if( chmod((const char *)pathBuf, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0 )
bt_prompt_trace(MOD_BT, "[ERR] chmod failed : errno=%u, %s", errno, strerror(errno));
bt_prompt_trace(MOD_BT, "[FS] -btmtk_fs_open handle=0x%x", bt_file_desc[i]);
return i;
}
#endif /* BTMTK_ON_WISE */
}
void HPAK_CreatePak( const char *filename, resource_t *DirEnt, byte *data, file_t *f )
{
int filelocation;
string pakname;
char md5[16];
char *temp;
MD5Context_t MD5_Hash;
file_t *fout;
if( !filename || !filename[0] )
{
MsgDev( D_ERROR, "HPAK_CreatePak: NULL name\n" );
return;
}
if(( f != NULL && data != NULL ) || ( f == NULL && data == NULL ))
{
MsgDev( D_ERROR, "HPAK_CreatePak: too many sources, please leave one.\n" );
return;
}
Q_strncpy( pakname, filename, sizeof( pakname ));
FS_StripExtension( pakname );
FS_DefaultExtension( pakname, ".hpk" );
MsgDev( D_INFO, "creating HPAK %s.\n", pakname );
fout = FS_Open( pakname, "wb", false );
if( !fout )
{
MsgDev( D_ERROR, "HPAK_CreatePak: can't write %s.\n", pakname );
return;
}
// let's hash it.
Q_memset( &MD5_Hash, 0, sizeof( MD5Context_t ));
MD5Init( &MD5_Hash );
if( data == NULL )
{
// there are better ways
filelocation = FS_Tell( f );
temp = Z_Malloc( DirEnt->nDownloadSize );
FS_Read( f, temp, DirEnt->nDownloadSize );
FS_Seek( f, filelocation, SEEK_SET );
MD5Update( &MD5_Hash, temp, DirEnt->nDownloadSize );
Mem_Free( temp );
}
else
{
MD5Update( &MD5_Hash, data, DirEnt->nDownloadSize );
}
MD5Final( md5, &MD5_Hash );
if( Q_memcmp( md5, DirEnt->rgucMD5_hash, 16 ))
{
MsgDev( D_ERROR, "HPAK_CreatePak: bad checksum for %s. Ignored\n", pakname );
return;
}
hash_pack_header.ident = IDCUSTOMHEADER;
hash_pack_header.version = IDCUSTOM_VERSION;
hash_pack_header.seek = 0;
FS_Write( fout, &hash_pack_header, sizeof( hash_pack_header ));
hash_pack_dir.count = 1;
hash_pack_dir.dirs = Z_Malloc( sizeof( hpak_dir_t ));
hash_pack_dir.dirs[0].DirectoryResource = *DirEnt;
hash_pack_dir.dirs[0].seek = FS_Tell( fout );
hash_pack_dir.dirs[0].size = DirEnt->nDownloadSize;
if( data == NULL )
{
HPAK_FileCopy( fout, f, hash_pack_dir.dirs[0].size );
}
else
{
FS_Write( fout, data, hash_pack_dir.dirs[0].size );
}
filelocation = FS_Tell( fout );
FS_Write( fout, &hash_pack_dir.count, sizeof( hash_pack_dir.count ));
FS_Write( fout, &hash_pack_dir.dirs[0], sizeof( hpak_dir_t ));
Mem_Free( hash_pack_dir.dirs );
Q_memset( &hash_pack_dir, 0, sizeof( hpak_container_t ));
hash_pack_header.seek = filelocation;
FS_Seek( fout, 0, SEEK_SET );
FS_Write( fout, &hash_pack_header, sizeof( hpak_header_t ));
FS_Close( fout );
}
TASK_ENTRY BAL_MainTaskEntry(void *pData)
{
INT8 IsUDisk = 0;
BOOL need_draw = TRUE;
INT32 active = 0; //当前活动的项目
INT32 result = APP_DEFAULT_RESULT;
INT32 ret = RESULT_NULL;
INT32 bt_active_ret = RESULT_NULL;
TM_SYSTEMTIME systime;
extern BOOL g_usb_connected;
// dump version and date
//hal_HstSendEvent(SYS_EVENT,0x11223344);
//hal_HstSendEvent(SYS_EVENT,GetPlatformVersion());
//hal_HstSendEvent(SYS_EVENT,GetPlatformRevision());
//hal_HstSendEvent(SYS_EVENT,GetPlatformBuildDate());
//hal_HstSendEvent(SYS_EVENT,AP_GetVersion());
//hal_HstSendEvent(SYS_EVENT,AP_GetBuildDate());
APP_ReadComPara(); //读取系统的全局变量。可以放在os初始化的过程中做
#if XDL_APP_SUPPORT_LOWBAT_DETECT==1//warkey 2.1
StartBatTimer();
#endif
gui_load_resource(g_comval->langid);
LED_SetPattern(GUI_LED_POWERON, 1);
#if APP_SUPPORT_LCD==1
if(AP_Support_LCD())
{
lcdd_Open();
GUI_Initialise(g_displayconfig.lcd_width, g_displayconfig.lcd_heigth);
GUI_SetTextColor(g_displayconfig.font_color);
GUI_SetBackColor(g_displayconfig.back_color);
}
#endif
if(g_test_mode)
{
NVRAMWriteData();
APP_Test_Mode();
}
APP_DisplaySysLogo(FALSE);
AP_GetBuildDate();//force link date time functions.
// check systemtime
TM_GetSystemTime(&systime);
if(systime.uHour >= 24 || systime.uDay == 0 || systime.uYear > 2050) // invalid date time
{
systime.uYear = 2012;
systime.uMonth = 8;
systime.uDay = 15;
systime.uHour = 12;
systime.uMinute = 30;
TM_SetSystemTime(&systime);
}
#if APP_SUPPORT_LCD==1
TIMER_SetAlarm(1);
#endif
hal_HstSendEvent(SYS_EVENT, 0x09250001);
APP_InitialFunPtr(); //初始化各个模块的回调函数，最后通过宏定义来实现开关
APP_Read_Sys_Config();
LED_SetPattern(GUI_LED_NONE, 1);
hal_HstSendEvent(BOOT_EVENT, 0x09558000);
#if APP_SUPPORT_LCD==0 //added for T_card update without LCD. Search TF card, if there is a file with the name "tflash_update.bin", then do the update.
#ifdef MCD_TFCARD_SUPPORT
{
INT32 file = -1, card_ok = -1;
UINT32 cur_data = AP_GetBuildDate();
UINT32 cur_time = AP_GetBuildTime();
boolean needupdate = FALSE;
hal_HstSendEvent(BOOT_EVENT, 0x98880001);
hal_HstSendEvent(BOOT_EVENT, cur_data);
hal_HstSendEvent(BOOT_EVENT, cur_time);
hal_HstSendEvent(BOOT_EVENT, 0x98880001);
card_ok = FS_MountDevice(FS_DEV_TYPE_TFLASH);
hal_HstSendEvent(BOOT_EVENT, card_ok);
if(card_ok == ERR_SUCCESS)
{
FS_FILE_ATTR file_attr;
TM_FILETIME sFileTime;
TM_SYSTEMTIME sSysTm;
UINT32 bin_createDate = 0;
UINT32 bin_createTime = 0;
UINT32 offset = 0;
file = FS_Open(UPDATE_TFLASH_BIN_NAME, FS_O_RDWR, 0);
hal_HstSendEvent(BOOT_EVENT, 0x09550000);
hal_HstSendEvent(BOOT_EVENT, file);
hal_HstSendEvent(BOOT_EVENT, 0x09550000);
#if 1
FS_Seek(file, 0xc, FS_SEEK_SET);
FS_Read(file, &offset, 4);
FS_Seek(file, ((offset & 0x00ffffff)) - 0x10, FS_SEEK_SET);
FS_Read(file, &bin_createDate, 4);
FS_Read(file, &bin_createTime, 4);
hal_HstSendEvent(BOOT_EVENT, 0x98880002);
hal_HstSendEvent(BOOT_EVENT, bin_createDate);
hal_HstSendEvent(BOOT_EVENT, bin_createTime);
hal_HstSendEvent(BOOT_EVENT, 0x98880002);
#else
if(FS_GetFileAttrByHandle(file, &file_attr) == 0)
{
sFileTime.DateTime = file_attr.i_mtime;
TM_FileTimeToSystemTime(sFileTime, &sSysTm);
bin_createDate = ((sSysTm.uYear) * 10000 + ((sSysTm.uMonth) * 100) + sSysTm.uDay);
bin_createTime = sSysTm.uHour * 10000 + sSysTm.uMinute * 100 + sSysTm.uSecond;
hal_HstSendEvent(BOOT_EVENT, 0x98880002);
hal_HstSendEvent(BOOT_EVENT, bin_createDate);
hal_HstSendEvent(BOOT_EVENT, bin_createTime);
hal_HstSendEvent(BOOT_EVENT, 0x98880002);
}
#endif
//if((cur_data<bin_createDate) ||
//(cur_data==bin_createDate && cur_time<bin_createTime))
if((cur_data != bin_createDate) || (cur_time != bin_createTime)) //只要不是同一软件就允许升级
{
needupdate = TRUE;
}
hal_HstSendEvent(BOOT_EVENT, needupdate);
hal_HstSendEvent(BOOT_EVENT, 0x98880008);
if(file >= 0 && needupdate)
{
Upgrade_Flash(file);
RestartSystem();
}
else
{
FS_Close(file);
}
}
}
#endif
#endif
g_last_reslt = result;
if(GetUsbCableStatus())
{
hal_HstSendEvent(APP_EVENT, 0x13113001);
result = RESULT_UDISK;
}
if(gpio_detect_linein() == GPIO_DETECTED)
{
hal_HstSendEvent(APP_EVENT, 0x13113002);
result = RESULT_LINE_IN;
}
// IsUDisk = g_comval->Onlinedev;
#ifdef SUPPORT_POWERON_ENTER_CHARGE_AP//warkey 2.1
app_trace(APP_MAIN_TRC, "GetBattery:%d", GetBattery());
if(-1 == GetBattery() && g_usb_connected == 0)
{
// hal_HstSendEvent(SYS_EVENT, 0x13062707);
hal_HstSendEvent(APP_EVENT, 0x13113003);
result = Charging_Entry();
}
#endif
while(1)
{
if(result==RESULT_STANDBY)
{
LED_SetPattern(GUI_LED_NONE, 0xde);
}
else
{
LED_SetPattern(GUI_LED_NONE, 1);
}
hal_HstSendEvent(SYS_EVENT, 0x09250002);
hal_HstSendEvent(SYS_EVENT, result);
if(result == RESULT_NULL || result == RESULT_MAIN)
{
#if APP_SUPPORT_MENU==1
if(AP_Support_MENU())
{
ui_auto_select = FALSE;
result = GUI_Display_Menu(GUI_MENU_MAIN, main_menu_callback);
g_last_reslt = RESULT_NULL;
if(result == RESULT_TIMEOUT || result == RESULT_IGNORE || result == RESULT_NULL)
{
result = RESULT_IDLE; // RESULT_CALENDAR;
}
}
else
#endif
{
if(RESULT_STANDBY != result)
{
result = g_last_reslt;
}
switch(result)
{
case RESULT_STANDBY:
break;
case RESULT_BT:
#if APP_SUPPORT_MUSIC==1
result = RESULT_MUSIC;
break;
case RESULT_MUSIC:
#endif
#if APP_SUPPORT_FM || APP_SUPPORT_LINEIN
//没有Line in时才进入FM 2012-9-27
if(gpio_detect_linein() == GPIO_DETECTED)
{
#if APP_SUPPORT_LINEIN ==1
result = RESULT_LINE_IN;
break;
#else
result = RESULT_RADIO;
break;
#endif
}
else
{
#if APP_SUPPORT_FM==1
result = RESULT_RADIO;
break;
#endif
}
case RESULT_LINE_IN:
case RESULT_RADIO:
#endif
#if APP_SUPPORT_RECORD
if(AP_Support_RECORD())
{
result = RESULT_RECORD_NOSTART;
break;
}
case RESULT_RECORD_NOSTART:
#endif
#if APP_SUPPORT_BLUETOOTH
result = RESULT_BT;
break;
#endif
default:
result = APP_DEFAULT_RESULT;
break;
}
}
}
else if(result == RESULT_POWERON)
{
if(AP_Support_LCD())
{
GUI_ClearScreen(NULL);
GUI_UpdateScreen(NULL);
}
LED_SetPattern(GUI_LED_POWERON, 1);
APP_DisplaySysLogo(TRUE);
LED_SetPattern(GUI_LED_NONE, 1);
if (g_comval->LightTime == 0) //每次开机判断一次！解决Bug Report:27
{
CloseBacklight();
}
else
{
OpenBacklight();
}
//APP_DUMP("g_last_reslt:", g_last_reslt);
result = g_last_reslt;
if(GetUsbCableStatus())
{
hal_HstSendEvent(APP_EVENT, 0x07021549);
result = RESULT_UDISK;
}
if(gpio_detect_linein() == GPIO_DETECTED)
{
hal_HstSendEvent(APP_EVENT, 0x07021550);
result = RESULT_LINE_IN;
}
need_draw = TRUE;
}
else //boot with param or result != 0
{
switch( result)
{
#if APP_SUPPORT_MUSIC==1
case RESULT_MUSIC:
hal_HstSendEvent(SYS_EVENT, 0x20120000);
ret = APP_ModCall(FUN_MUSIC, 0);
g_last_reslt = result;
result = ret;
#if APP_SUPPORT_FADE_INOUT==1
if(g_fade_volume_backup != -1)
{
// hal_HstSendEvent(SYS_EVENT, 0x13101701);
// hal_HstSendEvent(SYS_EVENT, g_fade_volume_backup);
SetPAVolume(g_fade_volume_backup);
g_fade_volume_backup = -1;
}
#endif
if(g_usb_audio_tcard&&GetUsbCableStatus())//plug in tcard when usb audio is running
{
result = RESULT_UDISK;
}
hal_HstSendEvent(SYS_EVENT, 0x20124444);
hal_HstSendEvent(SYS_EVENT, g_last_reslt);
hal_HstSendEvent(SYS_EVENT, result);
break;
#endif
case RESULT_RADIO:
hal_HstSendEvent(SYS_EVENT, 0x20120033);
ret = APP_ModCall(FUN_FM, 0);
hal_HstSendEvent(SYS_EVENT, 0x20120044);
g_last_reslt = result;
result = ret;
hal_HstSendEvent(SYS_EVENT, 0x20123001);
break;
case RESULT_RECORD_START: //进入录音
case RESULT_RECORD_NOSTART:
case RESULT_FMREC_START:
case RESULT_FMREC_NOSTART:
ret = APP_ModCall(FUN_RECORD, result); //传入result,以判断是否直接开始FM录音?
g_last_reslt = result;
result = ret;
break;
case RESULT_RECORD_SWITCH:
if(g_last_reslt == RESULT_RECORD_START || g_last_reslt == RESULT_RECORD_NOSTART)
{
result = RESULT_FMREC_NOSTART;
}
else if(g_last_reslt == RESULT_FMREC_START || g_last_reslt == RESULT_FMREC_NOSTART)
{
result = RESULT_RECORD_NOSTART;
}
ret = APP_ModCall(FUN_RECORD, result); //传入result,以判断是否直接开始FM录音?
g_last_reslt = result;
result = ret;
break;
case RESULT_CHARGING:
result = APP_ModCall(FUN_CHARGING, 0);
break;
case RESULT_IDLE:
//APP_DUMP("g_last_reslt:", g_last_reslt);
result = APP_ModCall(FUN_IDLE, 0);
break;
case RESULT_LINE_IN:
hal_HstSendEvent(SYS_EVENT, 0x20128888);
if(event_detected_displaying_log == RESULT_LINE_IN)
{
event_detected_displaying_log = 0;
}
result = APP_ModCall(FUN_LINEIN, 0);
hal_HstSendEvent(SYS_EVENT, 0x20129999);
hal_HstSendEvent(SYS_EVENT, g_last_reslt);
hal_HstSendEvent(SYS_EVENT, result);
// if(result == RESULT_NULL || result == RESULT_MAIN)
if(g_linein_out_event == 1)//line-in was removed
{
result = g_last_reslt;
if(result == RESULT_LINE_IN)
{
result = APP_DEFAULT_RESULT;
}
g_linein_out_event = 0;
if(g_usb_audio_linein&&GetUsbCableStatus())//plug in line-in when usb audio is running, so return usb audio again
{
result = RESULT_UDISK;
hal_HstSendEvent(SYS_EVENT, 0x13071801);
}
}
else
{
g_last_reslt = RESULT_LINE_IN;
}
break;
case RESULT_STANDBY:
{
extern UINT8 g_light_time;
#ifdef SUPPORT_POWERON_ENTER_CHARGE_AP//warkey 2.1
if(-1 == GetBattery())
{
result = Charging_Entry();
}
else
#endif
{
g_light_time = 0;
result = APP_StandBy();
if(g_comval->LightTime != 0)
{
g_light_time = g_comval->LightTime * 2;
OpenBacklight();
}
}
}
break;
#if APP_SUPPORT_CALIB_KEY==1
case RESULT_KEYCALIB:
result = APP_CalibKey();
break;
#endif
case RESULT_SYSTEM:
ret = APP_ModCall(FUN_SYSTEM_SETTING, 0);
g_last_reslt = result;
result = ret;
break;
case RESULT_ALARM:
ret = APP_ModCall(FUN_TIMER, 1);
g_last_reslt = result;
result = ret;
break;
case RESULT_TIMER:
ret = APP_ModCall(FUN_TIMER, 0);
g_last_reslt = result;
result = ret;
break;
case RESULT_UDISK:
//IsUDisk=1;
//if(IsUDisk)
{
if(g_usb_active_after_bt != 0)
{
g_usb_active_after_bt = 0;
}
if(event_detected_displaying_log == RESULT_UDISK)
{
event_detected_displaying_log = 0;
}
hal_HstSendEvent(SYS_EVENT, 0x09250003);
result = APP_ModCall(FUN_USB, 0);
hal_HstSendEvent(SYS_EVENT, 0x09250004);
}
if(result == RESULT_NULL)
{
result = g_last_reslt;
if(result == RESULT_UDISK)
{
result = APP_DEFAULT_RESULT;
}
}
if(result == RESULT_BT_ACTIVE)
{
bt_active_ret = RESULT_UDISK;
}
//fix udisk return, drop key up
//result = RESULT_MUSIC;
hal_HstSendEvent(SYS_EVENT, result);
break;
#if APP_SUPPORT_BLUETOOTH==1
case RESULT_BT:
hal_HstSendEvent(SYS_EVENT, 0x20120001);
ret = APP_ModCall(FUN_BT, -1);
g_last_reslt = result;
result = ret;
if(musicplay_timer)
{
COS_KillTimer(musicplay_timer);
musicplay_timer = 0;
}
hal_HstSendEvent(SYS_EVENT, 0x20127777);
hal_HstSendEvent(SYS_EVENT, g_last_reslt);
hal_HstSendEvent(SYS_EVENT, result);
break;
case RESULT_BT_ACTIVE:
hal_HstSendEvent(SYS_EVENT, 0x20120002);
if(bt_active_ret != RESULT_NULL)
{
result = APP_ModCall(FUN_BT, bt_active_ret);
}
else
{
result = APP_ModCall(FUN_BT, g_last_reslt);
}
//add by wuxiang
call_status = 0;
g_bt_call_time = 0;
bt_active_ret = RESULT_NULL;
if(musicplay_timer)
{
COS_KillTimer(musicplay_timer);
musicplay_timer = 0;
}
//add end
hal_HstSendEvent(SYS_EVENT, 0x20126666);
if(g_last_reslt == RESULT_ALARM)
{
result = RESULT_IDLE;
}
break;
#endif
case RESULT_CALENDAR:
ret = APP_ModCall(FUN_CALENDAR, 0);
g_last_reslt = result;
result = ret;
break;
default:
//APP_DUMP("never run here: ", result);
hal_HstSendEvent(SYS_EVENT, 0x20125555);
hal_HstSendEvent(SYS_EVENT, result);
result = RESULT_MAIN;
break;
}//switch(reault)
//APP_ReadComPara();
//IsUDisk = 1; //更新Onlinedev
need_draw = TRUE;
}
}//while never exit
}
int _main( int argc, char *argv[] )
{
int fres=0;
s32 ret=0;
struct IPCMessage *CMessage=NULL;
thread_set_priority( 0, 0x58 );
#ifdef DEBUG
dbgprintf("$IOSVersion: FFS-SD: %s %s 64M DEBUG$\n", __DATE__, __TIME__ );
#else
dbgprintf("$IOSVersion: FFS-SD: %s %s 64M Release$\n", __DATE__, __TIME__ );
#endif
//dbgprintf("FFS:Heap Init...");
HeapID = heap_create(Heap, sizeof Heap);
QueueSpace = heap_alloc(HeapID, 0x20);
//dbgprintf("ok\n");
QueueID = RegisterDevices();
if( QueueID < 0 )
{
ThreadCancel( 0, 0x77 );
}
sdhc_init();
//dbgprintf("FFS:Mounting SD...\n");
fres = f_mount(0, &fatfs);
//dbgprintf("FFS:f_mount():%d\n", fres);
if(fres != FR_OK)
{
//dbgprintf("FFS:Error %d while trying to mount SD\n", fres);
ThreadCancel( 0, 0x77 );
}
//dbgprintf("FFS:Clean up...");
//clean up folders
FS_Delete("/tmp");
FS_Delete("/import");
f_mkdir("/tmp");
f_mkdir("/import");
thread_set_priority( 0, 0x0B );
//dbgprintf("ok\n");
while (1)
{
ret = mqueue_recv(QueueID, (void *)&CMessage, 0);
if( ret != 0 )
{
//dbgprintf("FFS:mqueue_recv(%d) FAILED:%d\n", QueueID, ret);
continue;
}
//dbgprintf("FFS:Cmd:%d\n", CMessage->command );
switch( CMessage->command )
{
case IOS_OPEN:
{
ret = FS_Open( CMessage->open.device, CMessage->open.mode );
#ifdef DEBUG
if( ret != FS_NO_DEVICE )
dbgprintf("FFS:IOS_Open(\"%s\", %d):%d\n", CMessage->open.device, CMessage->open.mode, ret );
#endif
mqueue_ack( (void *)CMessage, ret);
}
break;
case IOS_CLOSE:
{
#ifdef DEBUG
dbgprintf("FFS:IOS_Close(%d):", CMessage->fd);
#endif
ret = FS_Close( CMessage->fd );
#ifdef DEBUG
dbgprintf("%d\n", ret );
#endif
mqueue_ack( (void *)CMessage, ret);
}
break;
case IOS_READ:
{
#ifdef DEBUG
dbgprintf("FFS:IOS_Read(%d, 0x%p, %u):", CMessage->fd, CMessage->read.data, CMessage->read.length );
#endif
ret = FS_Read( CMessage->fd, CMessage->read.data, CMessage->read.length );
#ifdef DEBUG
dbgprintf("%d\n", ret );
#endif
mqueue_ack( (void *)CMessage, ret );
}
break;
case IOS_WRITE:
{
#ifdef DEBUG
dbgprintf("FFS:IOS_Write(%d, 0x%p, %u)", CMessage->fd, CMessage->write.data, CMessage->write.length );
#endif
ret = FS_Write( CMessage->fd, CMessage->write.data, CMessage->write.length );
#ifdef DEBUG
dbgprintf(":%d\n", ret );
#endif
mqueue_ack( (void *)CMessage, ret );
}
break;
case IOS_SEEK:
{
#ifdef DEBUG
dbgprintf("FFS:IOS_Seek(%d, %x, %d):", CMessage->fd, CMessage->seek.offset, CMessage->seek.origin );
#endif
ret = FS_Seek( CMessage->fd, CMessage->seek.offset, CMessage->seek.origin );
#ifdef DEBUG
dbgprintf("%d\n", ret );
#endif
mqueue_ack( (void *)CMessage, ret );
}
break;
case IOS_IOCTL:
FFS_Ioctl(CMessage);
break;
case IOS_IOCTLV:
FFS_Ioctlv(CMessage);
break;
#ifdef EDEBUG
default:
dbgprintf("FFS:unimplemented/invalid msg: %08x\n", CMessage->command);
mqueue_ack( (void *)CMessage, -1017);
#endif
}
}
return 0;
}
intptr_t CL_CgameSystemCalls( intptr_t *args )
{
if( cls.cgInterface == 2 && args[0] >= CG_R_SETCLIPREGION && args[0] < CG_MEMSET )
{
if( args[0] < CG_S_STOPBACKGROUNDTRACK - 1 )
args[0] += 1;
else if( args[0] < CG_S_STOPBACKGROUNDTRACK + 4 )
args[0] += CG_PARSE_ADD_GLOBAL_DEFINE - CG_S_STOPBACKGROUNDTRACK + 1;
else if( args[0] < CG_PARSE_ADD_GLOBAL_DEFINE + 4 )
args[0] -= 4;
else if( args[0] >= CG_PARSE_SOURCE_FILE_AND_LINE && args[0] <= CG_S_SOUNDDURATION )
args[0] = CG_PARSE_SOURCE_FILE_AND_LINE - 1337 - args[0] ;
}
switch( args[0] )
{
case CG_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case CG_ERROR:
if( probingCG )
{
cls.cgInterface = 2; // this is a 1.1.0 cgame
return 0;
}
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( (vmCvar_t*)VMA(1), (const char*)VMA(2), (const char*)VMA(3), args[4] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( (vmCvar_t*)VMA(1) );
return 0;
case CG_CVAR_SET:
Cvar_SetSafe( (const char*)VMA(1), (const char*)VMA(2) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( (const char*)VMA(1), (char*)VMA(2), args[3] );
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer( args[1], (char*)VMA(2), args[3] );
return 0;
case CG_ARGS:
Cmd_ArgsBuffer( (char*)VMA(1), args[2] );
return 0;
case CG_LITERAL_ARGS:
Cmd_LiteralArgsBuffer( (char*)VMA(1), args[2] );
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( (const char*)VMA(1), (fileHandle_t*)VMA(2), (FS_Mode)args[3] );
case CG_FS_READ:
FS_Read( VMA(1), args[2], args[3] );
return 0;
case CG_FS_WRITE:
FS_Write( VMA(1), args[2], args[3] );
return 0;
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case CG_FS_SEEK:
return FS_Seek( (fileHandle_t)args[1], args[2], (FS_Origin)args[3] );
case CG_FS_GETFILELIST:
return FS_GetFileList( (const char*)VMA(1), (const char*)VMA(2), (char*)VMA(3), args[4] );
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( (const char*)VMA(1) );
return 0;
case CG_ADDCOMMAND:
Cmd_AddCommand( (const char*)VMA(1), NULL );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommandSafe( (const char*)VMA(1) );
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand((const char*)VMA(1), false);
return 0;
case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop
// Com_EventLoop(); // FIXME: if a server restarts here, BAD THINGS HAPPEN!
// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
// if there is a map change while we are downloading at pk3.
// ZOID
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( (const char*)VMA(1) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( (const float*)VMA(1), (const float*)VMA(2), false );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( (const float*)VMA(1), (const float*)VMA(2), true );
case CG_CM_POINTCONTENTS:
return CM_PointContents( (const float*)VMA(1), args[2] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( (const float*)VMA(1), (clipHandle_t)args[2],
(const float*)VMA(3), (const float*)VMA(4) );
case CG_CM_BOXTRACE:
CM_BoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
(float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7], TT_AABB );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
(float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7], TT_CAPSULE );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
(float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7],
(const float*)VMA(8), (const float*)VMA(9), TT_AABB );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
(float*)VMA(4), (float*)VMA(5), (clipHandle_t)args[6], args[7],
(const float*)VMA(8), (const float*)VMA(9), TT_CAPSULE );
return 0;
case CG_CM_BISPHERETRACE:
CM_BiSphereTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3), VMF(4), VMF(5), (clipHandle_t)args[6], args[7] );
return 0;
case CG_CM_TRANSFORMEDBISPHERETRACE:
CM_TransformedBiSphereTrace( (trace_t*)VMA(1), (const float*)VMA(2), (const float*)VMA(3),
VMF(4), VMF(5), (clipHandle_t)args[6], args[7], (const float*)VMA(8) );
return 0;
case CG_CM_MARKFRAGMENTS:
{
float (&arg2)[3][3] = *reinterpret_cast<float (*)[3][3]>(VMA(2));
return re.MarkFragments( args[1], arg2, (const float*)VMA(3), args[4], (float*)VMA(5), args[6], (markFragment_t*)VMA(7) );
}
case CG_S_STARTSOUND:
S_StartSound( (float*)VMA(1), args[2], args[3], (sfxHandle_t)args[4] );
return 0;
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( (sfxHandle_t)args[1], args[2] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds( (bool)args[1] );
return 0;
case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[1], (const float*)VMA(2), (const float*)VMA(3), (sfxHandle_t)args[4] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[1], (const float*)VMA(2), (const float*)VMA(3), (sfxHandle_t)args[4] );
return 0;
case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[1] );
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], (const float*)VMA(2) );
return 0;
case CG_S_RESPATIALIZE:
{
float (&arg3)[3][3] = *reinterpret_cast<float (*)[3][3]>(VMA(3));
S_Respatialize( args[1], (const float*)VMA(2), arg3, args[4] );
return 0;
}
case CG_S_REGISTERSOUND:
return S_RegisterSound( (const char*)VMA(1), (bool)args[2] );
case CG_S_SOUNDDURATION:
return S_SoundDuration( args[1] );
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( (const char*)VMA(1), (const char*)VMA(2) );
return 0;
case CG_R_LOADWORLDMAP:
re.LoadWorld( (const char*)VMA(1) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( (const char*)VMA(1) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( (const char*)VMA(1) );
case CG_R_REGISTERSHADER:
return re.RegisterShader( (const char*)VMA(1) );
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( (const char*)VMA(1) );
case CG_R_REGISTERFONT:
re.RegisterFont( (const char*)VMA(1), args[2], (fontInfo_t*)VMA(3));
return 0;
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( (const refEntity_t*)VMA(1) );
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( (qhandle_t)args[1], args[2], (const polyVert_t*)VMA(3), 1 );
return 0;
case CG_R_ADDPOLYSTOSCENE:
re.AddPolyToScene( (qhandle_t)args[1], args[2], (const polyVert_t*)VMA(3), args[4] );
return 0;
case CG_R_LIGHTFORPOINT:
return re.LightForPoint( (float*)VMA(1), (float*)VMA(2), (float*)VMA(3), (float*)VMA(4) );
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( (const float*)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( (const float*)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( (const refdef_t*)VMA(1) );
return 0;
case CG_R_SETCOLOR:
re.SetColor( (const float*)VMA(1) );
return 0;
case CG_R_SETCLIPREGION:
re.SetClipRegion( (const float*)VMA(1) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), (qhandle_t)args[9] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( (qhandle_t)args[1], (float*)VMA(2), (float*)VMA(3) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( (orientation_t*)VMA(1), args[2], args[3], args[4], VMF(5), (const char*)VMA(6) );
case CG_GETGLCONFIG:
CL_GetGlconfig( (glconfig_t*)VMA(1) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( (gameState_t*)VMA(1) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( (int*)VMA(1), (int*)VMA(2) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], (snapshot_t*)VMA(2) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], (usercmd_t*)VMA(2) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], VMF(2) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[1] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
// don't allow the cgame module to toggle the console
Key_SetCatcher( ( args[1] & ~KEYCATCH_CONSOLE ) | ( Key_GetCatcher() & KEYCATCH_CONSOLE ) );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( (const char*)VMA(1) );
case CG_GETDEMOSTATE:
return CL_DemoState( );
case CG_GETDEMOPOS:
return CL_DemoPos( );
case CG_GETDEMONAME:
CL_DemoName( (char*)VMA(1), args[2] );
return 0;
case CG_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], (char*)VMA(2), args[3] );
return 0;
case CG_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], (char*)VMA(2), args[3] );
return 0;
case CG_KEY_SETBINDING:
Key_SetBinding( args[1], (const char*)VMA(2) );
return 0;
case CG_PARSE_ADD_GLOBAL_DEFINE:
return Parse_AddGlobalDefine( (char*)VMA(1) );
case CG_PARSE_LOAD_SOURCE:
return Parse_LoadSourceHandle( (const char*)VMA(1) );
case CG_PARSE_FREE_SOURCE:
return Parse_FreeSourceHandle( args[1] );
case CG_PARSE_READ_TOKEN:
return Parse_ReadTokenHandle( args[1], (pc_token_t*)VMA(2) );
case CG_PARSE_SOURCE_FILE_AND_LINE:
return Parse_SourceFileAndLine( args[1], (char*)VMA(2), (int*)VMA(3) );
case CG_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( (bool)args[1] );
return 0;
case CG_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode( );
case CG_FIELD_COMPLETELIST:
Field_CompleteList( (char*)VMA(1) );
return 0;
case CG_MEMSET:
::memset( VMA(1), args[2], args[3] );
return 0;
case CG_MEMCPY:
::memcpy( VMA(1), VMA(2), args[3] );
return 0;
case CG_STRNCPY:
safe_strncpy( (char*)VMA(1), (const char*)VMA(2), args[3] );
return args[1];
case CG_SIN:
return FloatAsInt( sin( VMF(1) ) );
case CG_COS:
return FloatAsInt( cos( VMF(1) ) );
case CG_ATAN2:
return FloatAsInt( atan2( VMF(1), VMF(2) ) );
case CG_SQRT:
return FloatAsInt( sqrt( VMF(1) ) );
case CG_FLOOR:
return FloatAsInt( floor( VMF(1) ) );
case CG_CEIL:
return FloatAsInt( ceil( VMF(1) ) );
case CG_ACOS:
return FloatAsInt( Q_acos( VMF(1) ) );
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( (qtime_t*)VMA(1) );
case CG_SNAPVECTOR:
Q_SnapVector((float*)VMA(1));
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic((const char*)VMA(1), args[2], args[3], args[4], args[5], args[6]);
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]);
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic(args[1]);
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic(args[1]);
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( (const char*)VMA(1), (const char*)VMA(2), (const char*)VMA(3) );
return 0;
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( (char*)VMA(1), args[2] );
case CG_R_INPVS:
return re.inPVS( (const float*)VMA(1), (const float*)VMA(2) );
default:
assert(0);
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0] );
}
return 0;
}
/*
====================
CL_WriteDemoHeader
Write demo header
====================
*/
void CL_WriteDemoHeader( const char *name )
{
fs_offset_t copysize;
fs_offset_t savepos;
fs_offset_t curpos;
MsgDev( D_INFO, "recording to %s.\n", name );
cls.demofile = FS_Open( name, "wb", false );
cls.demotime = 0.0;
if( !cls.demofile )
{
MsgDev( D_ERROR, "couldn't open %s.\n", name );
return;
}
cls.demorecording = true;
cls.demowaiting = true; // don't start saving messages until a non-delta compressed message is received
Q_memset( &demo.header, 0, sizeof( demo.header ));
demo.header.id = IDEMOHEADER;
demo.header.dem_protocol = DEMO_PROTOCOL;
demo.header.net_protocol = PROTOCOL_VERSION;
Q_strncpy( demo.header.mapname, clgame.mapname, sizeof( demo.header.mapname ));
Q_strncpy( demo.header.gamedir, FS_Gamedir(), sizeof( demo.header.gamedir ));
// write header
FS_Write( cls.demofile, &demo.header, sizeof( demo.header ));
demo.directory.numentries = 2;
demo.directory.entries = Mem_Alloc( cls.mempool, sizeof( demoentry_t ) * demo.directory.numentries );
// DIRECTORY ENTRY # 0
demo.entry = &demo.directory.entries[0]; // only one here.
demo.entry->entrytype = DEMO_STARTUP;
demo.entry->playback_time = 0.0f; // startup takes 0 time.
demo.entry->offset = FS_Tell( cls.demofile ); // position for this chunk.
// finish off the startup info.
CL_WriteDemoCmdHeader( dem_stop, cls.demoheader );
// now copy the stuff we cached from the server.
copysize = savepos = FS_Tell( cls.demoheader );
FS_Seek( cls.demoheader, 0, SEEK_SET );
FS_FileCopy( cls.demofile, cls.demoheader, copysize );
// jump back to end, in case we record another demo for this session.
FS_Seek( cls.demoheader, savepos, SEEK_SET );
demo.starttime = CL_GetDemoRecordClock(); // setup the demo starttime
demo.realstarttime = demo.starttime;
demo.framecount = 0;
// now move on to entry # 1, the first data chunk.
curpos = FS_Tell( cls.demofile );
demo.entry->length = curpos - demo.entry->offset;
// now we are writing the first real lump.
demo.entry = &demo.directory.entries[1]; // first real data lump
demo.entry->entrytype = DEMO_NORMAL;
demo.entry->playback_time = 0.0f; // startup takes 0 time.
demo.entry->offset = FS_Tell( cls.demofile );
// demo playback should read this as an incoming message.
// write the client's realtime value out so we can synchronize the reads.
CL_WriteDemoCmdHeader( dem_jumptime, cls.demofile );
if( clgame.hInstance ) clgame.dllFuncs.pfnReset();
Cbuf_InsertText( "fullupdate\n" );
Cbuf_Execute();
}
void HPAK_AddLump( qboolean add_to_queue, const char *name, resource_t *DirEnt, byte *data, file_t *f )
{
int i, position, length;
string pakname1, pakname2;
char md5[16];
MD5Context_t MD5_Hash;
hpak_container_t hpak1, hpak2;
file_t *f1, *f2;
hpak_dir_t *dirs;
byte *temp;
if( !name || !name[0] )
{
MsgDev( D_ERROR, "HPAK_AddLump: NULL name\n" );
return;
}
if( !DirEnt )
{
MsgDev( D_ERROR, "HPAK_AddLump: invalid lump\n" );
return;
}
if( data == NULL && f == NULL )
{
MsgDev( D_ERROR, "HPAK_AddLump: missing lump data\n" );
return;
}
if( DirEnt->nDownloadSize < 1024 || DirEnt->nDownloadSize > 131072 )
{
MsgDev( D_ERROR, "HPAK_AddLump: invalid size %s\n", Q_pretifymem( DirEnt->nDownloadSize, 2 ));
return;
}
// hash it
Q_memset( &MD5_Hash, 0, sizeof( MD5Context_t ));
MD5Init( &MD5_Hash );
if( data == NULL )
{
// there are better ways
position = FS_Tell( f );
temp = Z_Malloc( DirEnt->nDownloadSize );
FS_Read( f, temp, DirEnt->nDownloadSize );
FS_Seek( f, position, SEEK_SET );
MD5Update( &MD5_Hash, temp, DirEnt->nDownloadSize );
Mem_Free( temp );
}
else
{
MD5Update( &MD5_Hash, data, DirEnt->nDownloadSize );
}
MD5Final( md5, &MD5_Hash );
if( Q_memcmp( md5, DirEnt->rgucMD5_hash, 0x10 ))
{
MsgDev( D_ERROR, "HPAK_AddLump: bad checksum for %s. Ignored\n", DirEnt->szFileName );
return;
}
if( add_to_queue )
{
HPAK_AddToQueue( name, DirEnt, data, f );
return;
}
Q_strncpy( pakname1, name, sizeof( pakname1 ));
FS_StripExtension( pakname1 );
FS_DefaultExtension( pakname1, ".hpk" );
f1 = FS_Open( pakname1, "rb", false );
if( !f1 )
{
// create new pack
HPAK_CreatePak( name, DirEnt, data, f );
return;
}
Q_strncpy( pakname2, pakname1, sizeof( pakname2 ));
FS_StripExtension( pakname2 );
FS_DefaultExtension( pakname2, ".hp2" );
f2 = FS_Open( pakname2, "w+b", false );
if( !f2 )
{
MsgDev( D_ERROR, "HPAK_AddLump: couldn't open %s.\n", pakname2 );
FS_Close( f1 );
return;
}
// load headers
FS_Read( f1, &hash_pack_header, sizeof( hpak_header_t ));
if( hash_pack_header.version != IDCUSTOM_VERSION )
{
// we don't check the HPAK bit for some reason.
MsgDev( D_ERROR, "HPAK_AddLump: %s does not have a valid header.\n", pakname2 );
FS_Close( f1 );
FS_Close( f2 );
}
length = FS_FileLength( f1 );
HPAK_FileCopy( f2, f1, length );
FS_Seek( f1, hash_pack_header.seek, SEEK_SET );
FS_Read( f1, &hpak1.count, sizeof( hpak1.count ));
if( hpak1.count < 1 || hpak1.count > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_AddLump: %s contain too many lumps.\n", pakname1 );
FS_Close( f1 );
FS_Close( f2 );
return;
}
// load the data
hpak1.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak1.count );
FS_Read( f1, hpak1.dirs, sizeof( hpak_dir_t ) * hpak1.count );
FS_Close( f1 );
if( HPAK_FindResource( &hpak1, DirEnt->rgucMD5_hash, NULL ))
{
Mem_Free( hpak1.dirs );
FS_Close( f2 );
}
// make a new container
hpak2.count = hpak1.count;
hpak2.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak2.count );
Q_memcpy( hpak2.dirs, hpak1.dirs, hpak1.count );
for( i = 0, dirs = NULL; i < hpak1.count; i++ )
{
if( Q_memcmp( hpak1.dirs[i].DirectoryResource.rgucMD5_hash, DirEnt->rgucMD5_hash, 16 ) < 0 )
{
dirs = &hpak1.dirs[i];
while( i < hpak1.count )
{
hpak2.dirs[i+1] = hpak1.dirs[i];
i++;
}
break;
}
}
if( dirs == NULL ) dirs = &hpak2.dirs[hpak2.count-1];
Q_memset( dirs, 0, sizeof( hpak_dir_t ));
FS_Seek( f2, hash_pack_header.seek, SEEK_SET );
dirs->DirectoryResource = *DirEnt;
dirs->seek = FS_Tell( f2 );
dirs->size = DirEnt->nDownloadSize;
if( !data ) HPAK_FileCopy( f2, f, dirs->size );
else FS_Write( f2, data, dirs->size );
hash_pack_header.seek = FS_Tell( f2 );
FS_Write( f2, &hpak2.count, sizeof( hpak2.count ));
for( i = 0; i < hpak2.count; i++ )
{
FS_Write( f2, &hpak2.dirs[i], sizeof( hpak_dir_t ));
}
// finalize
Mem_Free( hpak1.dirs );
Mem_Free( hpak2.dirs );
FS_Seek( f2, 0, SEEK_SET );
FS_Write( f2, &hash_pack_header, sizeof( hpak_header_t ));
FS_Close( f2 );
FS_Delete( pakname1 );
FS_Rename( pakname2, pakname1 );
}
/*
==================
CL_GetComment
==================
*/
qboolean CL_GetComment( const char *demoname, char *comment )
{
file_t *demfile;
demoheader_t demohdr;
demodirectory_t directory;
demoentry_t entry;
float playtime = 0.0f;
int i;
if( !comment ) return false;
demfile = FS_Open( demoname, "rb", false );
if( !demfile )
{
Q_strncpy( comment, "", MAX_STRING );
return false;
}
// read in the m_DemoHeader
FS_Read( demfile, &demohdr, sizeof( demoheader_t ));
if( demohdr.id != IDEMOHEADER )
{
FS_Close( demfile );
Q_strncpy( comment, "<corrupted>", MAX_STRING );
return false;
}
if( demohdr.net_protocol != PROTOCOL_VERSION || demohdr.dem_protocol != DEMO_PROTOCOL )
{
FS_Close( demfile );
Q_strncpy( comment, "<invalid protocol>", MAX_STRING );
return false;
}
// now read in the directory structure.
FS_Seek( demfile, demohdr.directory_offset, SEEK_SET );
FS_Read( demfile, &directory.numentries, sizeof( int ));
if( directory.numentries < 1 || directory.numentries > 1024 )
{
FS_Close( demfile );
Q_strncpy( comment, "<corrupted>", MAX_STRING );
return false;
}
for( i = 0; i < directory.numentries; i++ )
{
FS_Read( demfile, &entry, sizeof( demoentry_t ));
playtime += entry.playback_time;
}
// split comment to sections
Q_strncpy( comment, demohdr.mapname, CS_SIZE );
Q_strncpy( comment + CS_SIZE, "<No Title>", CS_SIZE ); // TODO: write titles or somewhat
Q_strncpy( comment + CS_SIZE * 2, va( "%g sec", playtime ), CS_TIME );
// all done
FS_Close( demfile );
return true;
}
static qboolean HPAK_Validate( const char *filename, qboolean quiet )
{
file_t *f;
hpak_dir_t *dataDir;
hpak_header_t hdr;
byte *dataPak;
int i, num_lumps;
MD5Context_t MD5_Hash;
string pakname;
resource_t *pRes;
char md5[16];
if( quiet ) HPAK_FlushHostQueue();
// not an error - just flush queue
if( !filename || !*filename )
return true;
Q_strncpy( pakname, filename, sizeof( pakname ));
FS_StripExtension( pakname );
FS_DefaultExtension( pakname, ".hpk" );
f = FS_Open( pakname, "rb", false );
if( !f )
{
MsgDev( D_INFO, "Couldn't find %s.\n", pakname );
return true;
}
if( !quiet ) MsgDev( D_INFO, "Validating %s\n", pakname );
FS_Read( f, &hdr, sizeof( hdr ));
if( hdr.ident != IDCUSTOMHEADER || hdr.version != IDCUSTOM_VERSION )
{
MsgDev( D_ERROR, "HPAK_ValidatePak: %s does not have a valid HPAK header.\n", pakname );
FS_Close( f );
return false;
}
FS_Seek( f, hdr.seek, SEEK_SET );
FS_Read( f, &num_lumps, sizeof( num_lumps ));
if( num_lumps < 1 || num_lumps > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_ValidatePak: %s has too many lumps %u.\n", pakname, num_lumps );
FS_Close( f );
return false;
}
if( !quiet ) MsgDev( D_INFO, "# of Entries: %i\n", num_lumps );
dataDir = Z_Malloc( sizeof( hpak_dir_t ) * num_lumps );
FS_Read( f, dataDir, sizeof( hpak_dir_t ) * num_lumps );
if( !quiet ) MsgDev( D_INFO, "# Type Size FileName : MD5 Hash\n" );
for( i = 0; i < num_lumps; i++ )
{
if( dataDir[i].size < 1 || dataDir[i].size > 131071 )
{
// odd max size
MsgDev( D_ERROR, "HPAK_ValidatePak: lump %i has invalid size %s\n", i, Q_pretifymem( dataDir[i].size, 2 ));
Mem_Free( dataDir );
FS_Close(f);
return false;
}
dataPak = Z_Malloc( dataDir[i].size );
FS_Seek( f, dataDir[i].seek, SEEK_SET );
FS_Read( f, dataPak, dataDir[i].size );
Q_memset( &MD5_Hash, 0, sizeof( MD5Context_t ));
MD5Init( &MD5_Hash );
MD5Update( &MD5_Hash, dataPak, dataDir[i].size );
MD5Final( md5, &MD5_Hash );
pRes = &dataDir[i].DirectoryResource;
MsgDev( D_INFO, "%i: %s %s %s: ", i, HPAK_TypeFromIndex( pRes->type ),
Q_pretifymem( pRes->nDownloadSize, 2 ), pRes->szFileName );
if( Q_memcmp( md5, pRes->rgucMD5_hash, 0x10 ))
{
if( quiet )
{
MsgDev( D_ERROR, "HPAK_ValidatePak: %s has invalid checksum.\n", pakname );
Mem_Free( dataPak );
Mem_Free( dataDir );
FS_Close( f );
return false;
}
else MsgDev( D_INFO, "failed\n" );
}
else
{
if( !quiet ) MsgDev( D_INFO, "OK\n" );
}
// at this point, it's passed our checks.
Mem_Free( dataPak );
}
Mem_Free( dataDir );
FS_Close( f );
return true;
}
// fseek() replacement
int S_OGG_Callback_seek(void *datasource, ogg_int64_t offset, int whence)
{
snd_stream_t *stream;
int retVal = 0;
// check if input is valid
if(!datasource)
{
errno = EBADF;
return -1;
}
// snd_stream_t in the generic pointer
stream = (snd_stream_t *) datasource;
// we must map the whence to its Q3 counterpart
switch (whence)
{
case SEEK_SET:
{
// set the file position in the actual file with the Q3 function
retVal = FS_Seek(stream->file, (long)offset, FS_SEEK_SET);
// something has gone wrong, so we return here
if(retVal < 0)
{
return retVal;
}
// keep track of file position
stream->pos = (int)offset;
break;
}
case SEEK_CUR:
{
// set the file position in the actual file with the Q3 function
retVal = FS_Seek(stream->file, (long)offset, FS_SEEK_CUR);
// something has gone wrong, so we return here
if(retVal < 0)
{
return retVal;
}
// keep track of file position
stream->pos += (int)offset;
break;
}
case SEEK_END:
{
// Quake 3 seems to have trouble with FS_SEEK_END
// so we use the file length and FS_SEEK_SET
// set the file position in the actual file with the Q3 function
retVal = FS_Seek(stream->file, (long)stream->length + (long)offset, FS_SEEK_SET);
// something has gone wrong, so we return here
if(retVal < 0)
{
return retVal;
}
// keep track of file position
stream->pos = stream->length + (int)offset;
break;
}
default:
{
// unknown whence, so we return an error
errno = EINVAL;
return -1;
}
}
// stream->pos shouldn't be smaller than zero or bigger than the filesize
stream->pos = (stream->pos < 0) ? 0 : stream->pos;
stream->pos = (stream->pos > stream->length) ? stream->length : stream->pos;
return 0;
}
qboolean HPAK_ResourceForHash( const char *filename, char *inHash, resource_t *pRes )
{
file_t *f;
hpak_t *hpak;
hpak_container_t hpakcontainer;
hpak_header_t hdr;
string pakname;
int ret;
if( !filename || !filename[0] )
return false;
for( hpak = hpak_queue; hpak != NULL; hpak = hpak->next )
{
if( !Q_stricmp( hpak->name, filename ) && !Q_memcmp( hpak->HpakResource.rgucMD5_hash, inHash, 0x10 ))
{
if( pRes != NULL ) *pRes = hpak->HpakResource;
return true;
}
}
Q_strncpy( pakname, filename, sizeof( pakname ));
FS_StripExtension( pakname );
FS_DefaultExtension( pakname, ".hpk" );
f = FS_Open( pakname, "rb", false );
if( !f ) return false;
FS_Read( f, &hdr, sizeof( hdr ));
if( hdr.ident != IDCUSTOMHEADER )
{
MsgDev( D_ERROR, "HPAK_ResourceForHash: %s it's not a HPK file.\n", pakname );
FS_Close( f );
return false;
}
if( hdr.version != IDCUSTOM_VERSION )
{
MsgDev( D_ERROR, "HPAK_ResourceForHash: %s has invalid version (%i should be %i).\n", pakname, hdr.version, IDCUSTOM_VERSION );
FS_Close( f );
return false;
}
FS_Seek( f, hdr.seek, SEEK_SET );
FS_Read( f, &hpakcontainer.count, sizeof( hpakcontainer.count ));
if( hpakcontainer.count < 1 || hpakcontainer.count > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_ResourceForHash: %s has too many lumps %u.\n", pakname, hpakcontainer.count );
FS_Close( f );
return false;
}
hpakcontainer.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpakcontainer.count );
FS_Read( f, hpakcontainer.dirs, sizeof( hpak_dir_t ) * hpakcontainer.count );
ret = HPAK_FindResource( &hpakcontainer, inHash, pRes );
Mem_Free( hpakcontainer.dirs );
FS_Close( f );
return(ret);
}
/* <65b51> ../engine/net_chan.c:412 */
void Netchan_Transmit(netchan_t *chan, int length, byte *data)
{
byte send_buf[NET_MAX_MESSAGE];
qboolean send_reliable;
qboolean send_reliable_fragment;
qboolean send_resending = false;
unsigned w1, w2;
int i, j;
float fRate;
sizebuf_t sb_send;
sb_send.data = send_buf;
sb_send.buffername = "Netchan_Transmit";
sb_send.maxsize = sizeof(send_buf);
sb_send.flags = 0;
sb_send.cursize = 0;
// check for message overflow
if (chan->message.flags & 2) {
Con_Printf("%s:Outgoing message overflow\n", NET_AdrToString(chan->remote_address));
return;
}
// if the remote side dropped the last reliable message, resend it
send_reliable = false;
if (chan->incoming_acknowledged > chan->last_reliable_sequence &&
chan->incoming_reliable_acknowledged != chan->reliable_sequence)
{
send_reliable = true;
send_resending = true;
}
//
// A packet can have "reliable payload + frag payload + unreliable payload
// frag payload can be a file chunk, if so, it needs to be parsed on the receiving end and reliable payload + unreliable payload need
// to be passed on to the message queue. The processing routine needs to be able to handle the case where a message comes in and a file
// transfer completes
//
//
// if the reliable transmit buffer is empty, copy the current message out
if (!chan->reliable_length)
{
qboolean send_frag = false;
fragbuf_t *pbuf;
// Will be true if we are active and should let chan->message get some bandwidth
int send_from_frag[MAX_STREAMS] = { 0, 0 };
int send_from_regular = 0;
#ifdef REHLDS_FIXES
if (chan->message.cursize > MAX_MSGLEN)
{
Netchan_CreateFragments_(chan == &g_pcls.netchan ? 1 : 0, chan, &chan->message);
SZ_Clear(&chan->message);
}
#endif
// If we have data in the waiting list(s) and we have cleared the current queue(s), then
// push the waitlist(s) into the current queue(s)
Netchan_FragSend(chan);
// Sending regular payload
send_from_regular = (chan->message.cursize) ? 1 : 0;
// Check to see if we are sending a frag payload
//
for (i = 0; i < MAX_STREAMS; i++)
{
if (chan->fragbufs[i])
{
send_from_frag[i] = 1;
}
}
// Stall reliable payloads if sending from frag buffer
if (send_from_regular && (send_from_frag[FRAG_NORMAL_STREAM]))
{
send_from_regular = false;
// If the reliable buffer has gotten too big, queue it at the end of everything and clear out buffer
//
if (chan->message.cursize > MAX_RELIABLE_PAYLOAD)
{
Netchan_CreateFragments_(chan == &g_pcls.netchan ? 1 : 0, chan, &chan->message);
SZ_Clear(&chan->message);
}
}
// Startpos will be zero if there is no regular payload
for (i = 0; i < MAX_STREAMS; i++)
{
chan->frag_startpos[i] = 0;
// Assume no fragment is being sent
chan->reliable_fragment[i] = 0;
chan->reliable_fragid[i] = 0;
chan->frag_length[i] = 0;
if (send_from_frag[i])
{
send_frag = true;
}
}
if (send_from_regular || send_frag)
{
chan->reliable_sequence ^= 1;
send_reliable = true;
}
if (send_from_regular) {
#ifdef REHLDS_FIXES
Q_memcpy(chan->reliable_buf, chan->message.data, chan->message.cursize);
#else
Q_memcpy(chan->reliable_buf, chan->message_buf, chan->message.cursize);
#endif
chan->reliable_length = chan->message.cursize;
SZ_Clear(&chan->message);
// If we send fragments, this is where they'll start
for (i = 0; i < MAX_STREAMS; i++) {
chan->frag_startpos[i] = chan->reliable_length;
}
}
for (i = 0; i < MAX_STREAMS; i++) {
int fragment_size;
// Is there something in the fragbuf?
pbuf = chan->fragbufs[i];
fragment_size = 0; // Compiler warning.
if (pbuf) {
fragment_size = pbuf->frag_message.cursize;
// Files set size a bit differently.
if (pbuf->isfile && !pbuf->isbuffer)
{
fragment_size = pbuf->size;
}
}
// Make sure we have enought space left
if (send_from_frag[i] && pbuf && ((chan->reliable_length + fragment_size) < MAX_RELIABLE_PAYLOAD)) {
chan->reliable_fragid[i] = MAKE_FRAGID(pbuf->bufferid, chan->fragbufcount[i]); // Which buffer are we sending?
// If it's not in-memory, then we'll need to copy it in frame the file handle.
if (pbuf->isfile && !pbuf->isbuffer) {
char compressedfilename[MAX_PATH];
FileHandle_t hfile;
if (pbuf->iscompressed)
{
Q_snprintf(compressedfilename, sizeof(compressedfilename), "%s.ztmp", pbuf->filename);
hfile = FS_Open(compressedfilename, "rb");
}
else
{
hfile = FS_Open(pbuf->filename, "rb");
}
FS_Seek(hfile, pbuf->foffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&pbuf->frag_message.data[pbuf->frag_message.cursize], pbuf->size, 1, hfile);
pbuf->frag_message.cursize += pbuf->size;
FS_Close(hfile);
}
Q_memcpy(chan->reliable_buf + chan->reliable_length, pbuf->frag_message.data, pbuf->frag_message.cursize);
chan->reliable_length += pbuf->frag_message.cursize;
chan->frag_length[i] = pbuf->frag_message.cursize;
// Unlink pbuf
Netchan_UnlinkFragment(pbuf, &chan->fragbufs[i]);
chan->reliable_fragment[i] = 1;
// Offset the rest of the starting positions
for (j = i + 1; j < MAX_STREAMS; j++)
{
chan->frag_startpos[j] += chan->frag_length[i];
}
}
}
}
// Prepare the packet header
w1 = chan->outgoing_sequence | (send_reliable << 31);
w2 = chan->incoming_sequence | (chan->incoming_reliable_sequence << 31);
send_reliable_fragment = false;
for (i = 0; i < MAX_STREAMS; i++)
{
if (chan->reliable_fragment[i])
{
send_reliable_fragment = true;
break;
}
}
if (send_reliable && send_reliable_fragment)
{
w1 |= (1 << 30);
}
chan->outgoing_sequence++;
MSG_WriteLong(&sb_send, w1);
MSG_WriteLong(&sb_send, w2);
if (send_reliable && send_reliable_fragment)
{
for (i = 0; i < MAX_STREAMS; i++)
{
if (chan->reliable_fragment[i])
{
MSG_WriteByte(&sb_send, 1);
MSG_WriteLong(&sb_send, chan->reliable_fragid[i]);
MSG_WriteShort(&sb_send, chan->frag_startpos[i]);
MSG_WriteShort(&sb_send, chan->frag_length[i]);
}
else
{
MSG_WriteByte(&sb_send, 0);
}
}
}
// Copy the reliable message to the packet first
if (send_reliable) {
SZ_Write(&sb_send, chan->reliable_buf, chan->reliable_length);
chan->last_reliable_sequence = chan->outgoing_sequence - 1;
}
// Is there room for the unreliable payload?
int max_send_size = MAX_ROUTEABLE_PACKET;
if (!send_resending)
max_send_size = sb_send.maxsize;
if ((max_send_size - sb_send.cursize) >= length) {
SZ_Write(&sb_send, data, length);
}
else {
Con_DPrintf("Netchan_Transmit: Unreliable would overfow, ignoring\n");
}
// Deal with packets that are too small for some networks
if (sb_send.cursize < 16) // Packet too small for some networks
{
int i;
// Go ahead and pad a full 16 extra bytes -- this only happens during authentication / signon
for (i = sb_send.cursize; i < 16; i++)
{
// Note that the server can parse svc_nop, too.
MSG_WriteByte(&sb_send, svc_nop);
}
}
int statId = chan->flow[FLOW_OUTGOING].current & 0x1F;
chan->flow[FLOW_OUTGOING].stats[statId].size = sb_send.cursize + UDP_HEADER_SIZE;
chan->flow[FLOW_OUTGOING].stats[statId].time = realtime;
chan->flow[FLOW_OUTGOING].current++;
Netchan_UpdateFlow(chan);
if (!g_pcls.demoplayback)
{
COM_Munge2(sb_send.data + 8, sb_send.cursize - 8, (unsigned char)(chan->outgoing_sequence - 1));
if (g_modfuncs.m_pfnProcessOutgoingNet)
g_modfuncs.m_pfnProcessOutgoingNet(chan, &sb_send);
NET_SendPacket(chan->sock, sb_send.cursize, sb_send.data, chan->remote_address);
}
if (g_psv.active && sv_lan.value != 0.0f && sv_lan_rate.value > MIN_RATE)
fRate = 1.0 / sv_lan_rate.value;
else
fRate = 1.0 / chan->rate;
if (chan->cleartime < realtime) {
chan->cleartime = realtime;
}
chan->cleartime += (sb_send.cursize + UDP_HEADER_SIZE) * fRate;
if (net_showpackets.value != 0.0f && net_showpackets.value != 2.0f) {
char c = (chan == &g_pcls.netchan) ? 'c' : 's';
Con_Printf(" %c --> sz=%i seq=%i ack=%i rel=%i tm=%f\n"
, c
, sb_send.cursize
, chan->outgoing_sequence - 1
, chan->incoming_sequence
, send_reliable ? 1 : 0
, (float)(chan == &g_pcls.netchan ? g_pcl.time : g_psv.time));
}
}
qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte **buffer, int *size )
{
file_t *f;
int i, num_lumps;
hpak_dir_t *direntries;
byte *tmpbuf;
string pakname;
hpak_t *queue;
hpak_header_t hdr;
if( !filename || !filename[0] )
return false;
if( buffer ) *buffer = NULL;
if( size ) *size = 0;
for( queue = hpak_queue; queue != NULL; queue = queue->next )
{
if( !Q_stricmp(queue->name, filename ) && !Q_memcmp( queue->HpakResource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
{
if( buffer )
{
tmpbuf = Z_Malloc( queue->size );
Q_memcpy( tmpbuf, queue->data, queue->size );
*buffer = tmpbuf;
}
if( size ) *size = queue->size;
return true;
}
}
Q_strncpy( pakname, filename, sizeof( pakname ));
FS_StripExtension( pakname );
FS_DefaultExtension( pakname, ".hpk" );
f = FS_Open( pakname, "rb", false );
if( !f ) return false;
FS_Read( f, &hdr, sizeof( hdr ));
if( hdr.ident != IDCUSTOMHEADER )
{
MsgDev( D_ERROR, "HPAK_GetDataPointer: %s it's not a HPK file.\n", pakname );
FS_Close( f );
return false;
}
if( hdr.version != IDCUSTOM_VERSION )
{
MsgDev( D_ERROR, "HPAK_GetDataPointer: %s has invalid version (%i should be %i).\n", pakname, hdr.version, IDCUSTOM_VERSION );
FS_Close( f );
return false;
}
FS_Seek( f, hdr.seek, SEEK_SET );
FS_Read( f, &num_lumps, sizeof( num_lumps ));
if( num_lumps < 1 || num_lumps > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_GetDataPointer: %s has too many lumps %u.\n", filename, num_lumps );
FS_Close( f );
return false;
}
direntries = Z_Malloc( sizeof( hpak_dir_t ) * num_lumps );
FS_Read( f, direntries, sizeof( hpak_dir_t ) * num_lumps );
for( i = 0; i < num_lumps; i++ )
{
if( !Q_memcmp( direntries[i].DirectoryResource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
{
FS_Seek( f, direntries[i].seek, SEEK_SET );
if( buffer && direntries[i].size > 0 )
{
tmpbuf = Z_Malloc( direntries[i].size );
FS_Read( f, tmpbuf, direntries[i].size );
*buffer = tmpbuf;
}
Mem_Free( direntries );
FS_Close( f );
return true;
}
}
Mem_Free( direntries );
FS_Close( f );
return false;
}
/*
====================
CL_UISystemCalls
The ui module is making a system call
====================
*/
intptr_t CL_UISystemCalls( intptr_t *args ) {
switch ( args[0] ) {
case UI_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case UI_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case UI_MILLISECONDS:
return Sys_Milliseconds();
case UI_CVAR_REGISTER:
Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
return 0;
case UI_CVAR_UPDATE:
Cvar_Update( VMA( 1 ) );
return 0;
case UI_CVAR_SET:
Cvar_SetSafe( VMA(1), VMA(2) );
return 0;
case UI_CVAR_VARIABLEVALUE:
return FloatAsInt( Cvar_VariableValue( VMA( 1 ) ) );
case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[3] );
return 0;
case UI_CVAR_SETVALUE:
Cvar_SetValueSafe( VMA(1), VMF(2) );
return 0;
case UI_CVAR_RESET:
Cvar_Reset( VMA( 1 ) );
return 0;
case UI_CVAR_CREATE:
Cvar_Register( NULL, VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], VMA( 2 ), args[3] );
return 0;
case UI_ARGC:
return Cmd_Argc();
case UI_ARGV:
Cmd_ArgvBuffer( args[1], VMA( 2 ), args[3] );
return 0;
case UI_CMD_EXECUTETEXT:
if(args[1] == EXEC_NOW
&& (!strncmp(VMA(2), "snd_restart", 11)
|| !strncmp(VMA(2), "vid_restart", 11)
|| !strncmp(VMA(2), "quit", 5)))
{
Com_Printf (S_COLOR_YELLOW "turning EXEC_NOW '%.11s' into EXEC_INSERT\n", (const char*)VMA(2));
args[1] = EXEC_INSERT;
}
Cbuf_ExecuteText( args[1], VMA( 2 ) );
return 0;
case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[3] );
case UI_FS_READ:
FS_Read( VMA( 1 ), args[2], args[3] );
return 0;
//----(SA) added
case UI_FS_SEEK:
FS_Seek( args[1], args[2], args[3] );
return 0;
//----(SA) end
case UI_FS_WRITE:
FS_Write( VMA( 1 ), args[2], args[3] );
return 0;
case UI_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case UI_FS_DELETEFILE:
return FS_Delete( VMA( 1 ) );
case UI_FS_GETFILELIST:
return FS_GetFileList( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
case UI_R_REGISTERMODEL:
return re.RegisterModel( VMA( 1 ) );
case UI_R_REGISTERSKIN:
return re.RegisterSkin( VMA( 1 ) );
case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA( 1 ) );
case UI_R_CLEARSCENE:
re.ClearScene();
return 0;
case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA( 1 ) );
return 0;
case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA( 3 ) );
return 0;
// Ridah
case UI_R_ADDPOLYSTOSCENE:
re.AddPolysToScene( args[1], args[2], VMA( 3 ), args[4] );
return 0;
// done.
case UI_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6] );
return 0;
case UI_R_ADDCORONATOSCENE:
re.AddCoronaToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6], args[7] );
return 0;
case UI_R_RENDERSCENE:
re.RenderScene( VMA( 1 ) );
return 0;
case UI_R_SETCOLOR:
re.SetColor( VMA( 1 ) );
return 0;
case UI_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9] );
return 0;
case UI_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA( 2 ), VMA( 3 ) );
return 0;
case UI_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case UI_CM_LERPTAG:
return re.LerpTag( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
case UI_S_REGISTERSOUND:
#ifdef DOOMSOUND ///// (SA) DOOMSOUND
return S_RegisterSound( VMA( 1 ) );
#else
return S_RegisterSound( VMA( 1 ), qfalse );
#endif ///// (SA) DOOMSOUND
case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
//----(SA) added
case UI_S_FADESTREAMINGSOUND:
S_FadeStreamingSound( VMF( 1 ), args[2], args[3] );
return 0;
case UI_S_FADEALLSOUNDS:
S_FadeAllSounds( VMF( 1 ), args[2] );
return 0;
//----(SA) end
case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA( 2 ), args[3] );
return 0;
case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA( 2 ), args[3] );
return 0;
case UI_KEY_SETBINDING:
Key_SetBinding( args[1], VMA( 2 ) );
return 0;
case UI_KEY_ISDOWN:
return Key_IsDown( args[1] );
case UI_KEY_GETOVERSTRIKEMODE:
return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[1] );
return 0;
case UI_KEY_CLEARSTATES:
Key_ClearStates();
return 0;
case UI_KEY_GETCATCHER:
return Key_GetCatcher();
case UI_KEY_SETCATCHER:
// Don't allow the ui module to close the console
Key_SetCatcher( args[1] | ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) );
return 0;
case UI_GETCLIPBOARDDATA:
CL_GetClipboardData( VMA(1), args[2] );
return 0;
case UI_GETCLIENTSTATE:
GetClientState( VMA( 1 ) );
return 0;
case UI_GETGLCONFIG:
CL_GetGlconfig( VMA( 1 ) );
return 0;
case UI_GETCONFIGSTRING:
return GetConfigString( args[1], VMA( 2 ), args[3] );
case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers();
return 0;
case UI_LAN_SAVECACHEDSERVERS:
LAN_SaveServersToCache();
return 0;
case UI_LAN_ADDSERVER:
return LAN_AddServer( args[1], VMA( 2 ), VMA( 3 ) );
case UI_LAN_REMOVESERVER:
LAN_RemoveServer( args[1], VMA( 2 ) );
return 0;
case UI_LAN_GETPINGQUEUECOUNT:
return LAN_GetPingQueueCount();
case UI_LAN_CLEARPING:
LAN_ClearPing( args[1] );
return 0;
case UI_LAN_GETPING:
LAN_GetPing( args[1], VMA( 2 ), args[3], VMA( 4 ) );
return 0;
case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], VMA( 2 ), args[3] );
return 0;
case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount( args[1] );
case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], VMA( 3 ), args[4] );
return 0;
case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], VMA( 3 ), args[4] );
return 0;
case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], args[3] );
return 0;
case UI_LAN_SERVERISVISIBLE:
return LAN_ServerIsVisible( args[1], args[2] );
case UI_LAN_UPDATEVISIBLEPINGS:
return LAN_UpdateVisiblePings( args[1] );
case UI_LAN_RESETPINGS:
LAN_ResetPings( args[1] );
return 0;
case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( VMA( 1 ), VMA( 2 ), args[3] );
case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
case UI_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case UI_GET_CDKEY:
CLUI_GetCDKey( VMA( 1 ), args[2] );
return 0;
case UI_SET_CDKEY:
#ifndef STANDALONE
CLUI_SetCDKey( VMA( 1 ) );
#endif
return 0;
case UI_R_REGISTERFONT:
re.RegisterFont( VMA( 1 ), args[2], VMA( 3 ) );
return 0;
case UI_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return args[1];
case UI_MEMCPY:
Com_Memset( VMA(1), args[2], args[3] );
return args[1];
case UI_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case UI_SIN:
return FloatAsInt( sin( VMF( 1 ) ) );
case UI_COS:
return FloatAsInt( cos( VMF( 1 ) ) );
case UI_ATAN2:
return FloatAsInt( atan2( VMF( 1 ), VMF( 2 ) ) );
case UI_SQRT:
return FloatAsInt( sqrt( VMF( 1 ) ) );
case UI_FLOOR:
return FloatAsInt( floor( VMF( 1 ) ) );
case UI_CEIL:
return FloatAsInt( ceil( VMF( 1 ) ) );
case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA( 1 ) );
case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA( 1 ) );
case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA( 2 ) );
case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA( 2 ), VMA( 3 ) );
case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case UI_S_STARTBACKGROUNDTRACK:
// S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ), args[3] ); //----(SA) added fadeup time
S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ) );
return 0;
case UI_REAL_TIME:
return Com_RealTime( VMA( 1 ) );
case UI_CIN_PLAYCINEMATIC:
Com_DPrintf( "UI_CIN_PlayCinematic\n" );
return CIN_PlayCinematic( VMA( 1 ), args[2], args[3], args[4], args[5], args[6] );
case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[1] );
case UI_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[1] );
case UI_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[1] );
return 0;
case UI_CIN_SETEXTENTS:
CIN_SetExtents( args[1], args[2], args[3], args[4], args[5] );
return 0;
case UI_R_REMAP_SHADER:
re.RemapShader( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case UI_VERIFY_CDKEY:
return CL_CDKeyValidate( VMA( 1 ), VMA( 2 ) );
// NERVE - SMF
case UI_CL_GETLIMBOSTRING:
return CL_GetLimboString( args[1], VMA( 2 ) );
// -NERVE - SMF
// New in IORTCW
case UI_ALLOC:
return VM_Alloc( args[1] );
default:
Com_Error( ERR_DROP, "Bad UI system trap: %ld", (long int) args[0] );
}
return 0;
}
/*
====================
CheckPendingDownloads
checks if there are free download slots to start new downloads in.
To not start too many downloads at once, only one download is added at a time,
up to a maximum number of cl_curl_maxdownloads are running.
====================
*/
static void CheckPendingDownloads(void)
{
const char *h;
char urlbuf[1024];
char vabuf[1024];
if(!curl_dll)
return;
if(numdownloads < cl_curl_maxdownloads.integer)
{
downloadinfo *di;
for(di = downloads; di; di = di->next)
{
if(!di->started)
{
if(!di->buffer)
{
Con_Printf("Downloading %s -> %s", CleanURL(di->url, urlbuf, sizeof(urlbuf)), di->filename);
di->stream = FS_OpenRealFile(di->filename, "ab", false);
if(!di->stream)
{
Con_Printf("\nFAILED: Could not open output file %s\n", di->filename);
Curl_EndDownload(di, CURL_DOWNLOAD_FAILED, CURLE_OK, NULL);
return;
}
FS_Seek(di->stream, 0, SEEK_END);
di->startpos = FS_Tell(di->stream);
if(di->startpos > 0)
Con_Printf(", resuming from position %ld", (long) di->startpos);
Con_Print("...\n");
}
else
{
Con_DPrintf("Downloading %s -> memory\n", CleanURL(di->url, urlbuf, sizeof(urlbuf)));
di->startpos = 0;
}
di->curle = qcurl_easy_init();
di->slist = NULL;
qcurl_easy_setopt(di->curle, CURLOPT_URL, di->url);
if(cl_curl_useragent.integer)
{
const char *ua
#ifdef HTTP_USER_AGENT
= HTTP_USER_AGENT;
#else
= engineversion;
#endif
if(!ua)
ua = "";
if(*cl_curl_useragent_append.string)
ua = va(vabuf, sizeof(vabuf), "%s%s%s",
ua,
(ua[0] && ua[strlen(ua)-1] != ' ')
? " "
: "",
cl_curl_useragent_append.string);
qcurl_easy_setopt(di->curle, CURLOPT_USERAGENT, ua);
}
else
qcurl_easy_setopt(di->curle, CURLOPT_USERAGENT, "");
qcurl_easy_setopt(di->curle, CURLOPT_REFERER, di->referer);
qcurl_easy_setopt(di->curle, CURLOPT_RESUME_FROM, (long) di->startpos);
qcurl_easy_setopt(di->curle, CURLOPT_FOLLOWLOCATION, 1);
qcurl_easy_setopt(di->curle, CURLOPT_WRITEFUNCTION, CURL_fwrite);
qcurl_easy_setopt(di->curle, CURLOPT_LOW_SPEED_LIMIT, (long) 256);
qcurl_easy_setopt(di->curle, CURLOPT_LOW_SPEED_TIME, (long) 45);
qcurl_easy_setopt(di->curle, CURLOPT_WRITEDATA, (void *) di);
qcurl_easy_setopt(di->curle, CURLOPT_PRIVATE, (void *) di);
qcurl_easy_setopt(di->curle, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP);
if(qcurl_easy_setopt(di->curle, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP) != CURLE_OK)
{
Con_Printf("^1WARNING:^7 for security reasons, please upgrade to libcurl 7.19.4 or above. In a later version of DarkPlaces, HTTP redirect support will be disabled for this libcurl version.\n");
//qcurl_easy_setopt(di->curle, CURLOPT_FOLLOWLOCATION, 0);
}
if(di->post_content_type)
{
qcurl_easy_setopt(di->curle, CURLOPT_POST, 1);
qcurl_easy_setopt(di->curle, CURLOPT_POSTFIELDS, di->postbuf);
qcurl_easy_setopt(di->curle, CURLOPT_POSTFIELDSIZE, di->postbufsize);
di->slist = qcurl_slist_append(di->slist, va(vabuf, sizeof(vabuf), "Content-Type: %s", di->post_content_type));
}
// parse extra headers into slist
// \n separated list!
h = di->extraheaders;
while(h)
{
const char *hh = strchr(h, '\n');
if(hh)
{
char *buf = (char *) Mem_Alloc(tempmempool, hh - h + 1);
memcpy(buf, h, hh - h);
buf[hh - h] = 0;
di->slist = qcurl_slist_append(di->slist, buf);
h = hh + 1;
}
else
{
di->slist = qcurl_slist_append(di->slist, h);
h = NULL;
}
}
qcurl_easy_setopt(di->curle, CURLOPT_HTTPHEADER, di->slist);
qcurl_multi_add_handle(curlm, di->curle);
di->started = true;
++numdownloads;
if(numdownloads >= cl_curl_maxdownloads.integer)
break;
}
