RomkaZVO/xash3d-fwgs
1
0
Fork 0
mirror of https://github.com/FWGS/xash3d-fwgs.git synced 2026-08-05 03:24:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

engine: common: refactor variable declarations

Browse Source
This commit is contained in:
Alibek Omarov
2026-05-20 17:51:18 +05:00
committed by a1batross
parent e8845fc404
commit c6c1163aa0
44 changed files with 1346 additions and 2203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
engine/common/base_cmd.c
View File

@@ -43,16 +43,12 @@ Find base command in bucket
*/
static base_command_hashmap_t *BaseCmd_FindInBucket( base_command_hashmap_t *bucket, base_command_type_e type, const char *name )
{
base_command_hashmap_t *i;
for( i = bucket; i != NULL; i = i->next )
for( base_command_hashmap_t *i = bucket; i != NULL; i = i->next )
{
int cmp;
if( i->type != type )
continue;
cmp = Q_stricmp( i->name, name );
int cmp = Q_stricmp( i->name, name );
if( cmp < 0 )
continue;
@@ -147,16 +143,16 @@ Add new typed base command to hashmap
*/
void BaseCmd_Insert( base_command_type_e type, base_command_t *basecmd, const char *name )
{
base_command_hashmap_t *elem, *cur, *find;
uint hash = BaseCmd_HashKey( name );
size_t len = Q_strlen( name );
base_command_hashmap_t *elem = Mem_Malloc( basecmd_pool, sizeof( base_command_hashmap_t ) + len + 1 );
elem = Mem_Malloc( basecmd_pool, sizeof( base_command_hashmap_t ) + len + 1 );
elem->basecmd = basecmd;
elem->type = type;
Q_strncpy( elem->name, name, len + 1 );
// link the variable in alphanumerical order
base_command_hashmap_t *cur, *find;
for( cur = NULL, find = hashed_cmds[hash];
find && Q_stricmp( find->name, elem->name ) < 0;
cur = find, find = find->next );
@@ -181,12 +177,10 @@ void BaseCmd_Remove( base_command_type_e type, const char *name )
for( prev = NULL, i = hashed_cmds[hash]; i != NULL; prev = i, i = i->next )
{
int cmp;
if( i->type != type )
continue;
cmp = Q_stricmp( i->name, name );
int cmp = Q_stricmp( i->name, name );
if( cmp < 0 )
continue;
@@ -241,11 +235,10 @@ void BaseCmd_Stats_f( void )
for( int i = 0; i < HASH_SIZE; i++ )
{
base_command_hashmap_t *hm;
int len = 0;
// count bucket length
for( hm = hashed_cmds[i]; hm; hm = hm->next, len++ );
for( base_command_hashmap_t *hm = hashed_cmds[i]; hm; hm = hm->next, len++ );
if( len == 0 )
{
@@ -300,11 +293,8 @@ void BaseCmd_Test_f( void )
for( int i = 0; i < 1000; i++ )
{
cmdalias_t *a;
void *cmd;
// Cmd_LookupCmds don't allows to check alias, so just iterate
for( a = Cmd_AliasGetList(); a; a = a->next, stats.lookups++ )
for( cmdalias_t *a = Cmd_AliasGetList(); a; a = a->next, stats.lookups++ )
{
if( !BaseCmd_Find( HM_CMDALIAS, a->name ))
{
@@ -313,7 +303,7 @@ void BaseCmd_Test_f( void )
}
}
for( cmd = Cmd_GetFirstFunctionHandle(); cmd;
for( void *cmd = Cmd_GetFirstFunctionHandle(); cmd;
cmd = Cmd_GetNextFunctionHandle( cmd ), stats.lookups++ )
{
if( !BaseCmd_Find( HM_CMD, Cmd_GetName( cmd )))

14
engine/common/cfgscript.c
View File

@@ -77,9 +77,7 @@ Determine script variable type
*/
static cvartype_t CSCR_ParseType( parserstate_t *ps )
{
int i;
for( i = 1; i < T_COUNT; i++ )
for( int i = 1; i < T_COUNT; i++ )
{
if( CSCR_ExpectString( ps, cvartypes[i], false, false ))
return i;
@@ -213,11 +211,11 @@ will callback on each scrvardef_t
static int CSCR_ParseFile( const char *scriptfilename,
void (*callback)( scrvardef_t *var, void * ), void *userdata )
{
parserstate_t state = { 0 };
qboolean success = false;
int count = 0;
fs_offset_t length = 0;
char *start;
parserstate_t state = { 0 };
qboolean success = false;
int count = 0;
fs_offset_t length = 0;
char *start;
state.filename = scriptfilename;
state.buf = start = (char *)FS_LoadFile( scriptfilename, &length, true );

79
engine/common/cmd.c
View File

@@ -66,15 +66,13 @@ Cbuf_GetSpace
*/
static void *Cbuf_GetSpace( cmdbuf_t *buf, int length )
{
void *data;
if(( buf->cursize + length ) >= sizeof( buf->data ))
{
buf->cursize = 0;
Host_Error( "%s: overflow\n", __func__ );
}
data = buf->data + buf->cursize;
void *data = buf->data + buf->cursize;
buf->cursize += length;
return data;
@@ -168,10 +166,8 @@ Cbuf_Execute
*/
static void Cbuf_ExecuteCommandsFromBuffer( cmdbuf_t *buf, qboolean isPrivileged, int cmdsToExecute )
{
char *text;
char line[MAX_CMD_LINE];
int i, quotes;
char *comment;
int i;
while( buf->cursize )
{
@@ -189,10 +185,10 @@ static void Cbuf_ExecuteCommandsFromBuffer( cmdbuf_t *buf, qboolean isPrivileged
}
// find a \n or ; line break
text = (char *)buf->data;
char *text = (char *)buf->data;
quotes = false;
comment = NULL;
int quotes = false;
char *comment = NULL;
for( i = 0; i < buf->cursize; i++ )
{
@@ -384,9 +380,7 @@ Just prints the rest of the line to the console
*/
static void Cmd_Echo_f( void )
{
int i;
for( i = 1; i < Cmd_Argc(); i++ )
for( int i = 1; i < Cmd_Argc(); i++ )
Con_Printf( "%s ", Cmd_Argv( i ));
Con_Printf( "\n" );
}
@@ -402,8 +396,6 @@ static void Cmd_Alias_f( void )
{
cmdalias_t *a;
char cmd[MAX_CMD_LINE];
int i, c;
const char *s;
if( Cmd_Argc() == 1 )
{
@@ -413,7 +405,7 @@ static void Cmd_Alias_f( void )
return;
}
s = Cmd_Argv( 1 );
const char *s = Cmd_Argv( 1 );
if( Q_strlen( s ) >= MAX_ALIAS_NAME )
{
@@ -452,9 +444,9 @@ static void Cmd_Alias_f( void )
// copy the rest of the command line
cmd[0] = 0; // start out with a null string
c = Cmd_Argc();
int c = Cmd_Argc();
for( i = 2; i < c; i++ )
for( int i = 2; i < c; i++ )
{
if( i != 2 ) Q_strncat( cmd, " ", sizeof( cmd ));
Q_strncat( cmd, Cmd_Argv( i ), sizeof( cmd ));
@@ -473,20 +465,16 @@ Remove existing aliases.
*/
static void Cmd_UnAlias_f ( void )
{
cmdalias_t *a, *p;
const char *s;
int i;
if( Cmd_Argc() == 1 )
{
Con_Printf( S_USAGE "unalias alias1 [alias2 ...]\n" );
return;
}
for( i = 1; i < Cmd_Argc(); i++ )
for( int i = 1; i < Cmd_Argc(); i++ )
{
s = Cmd_Argv( i );
p = NULL;
const char *s = Cmd_Argv( i );
cmdalias_t *a, *p = NULL;
for( a = cmd_alias; a; p = a, a = a->next )
{
@@ -586,10 +574,9 @@ will point into this temporary buffer.
void Cmd_TokenizeString( const char *text )
{
char cmd_token[MAX_CMD_BUFFER];
int i;
// clear the args from the last string
for( i = 0; i < cmd_argc; i++ )
for( int i = 0; i < cmd_argc; i++ )
Mem_Free( cmd_argv[i] );
cmd_argc = 0; // clear previous args
@@ -709,15 +696,13 @@ Cmd_RemoveCommand
*/
void GAME_EXPORT Cmd_RemoveCommand( const char *cmd_name )
{
cmd_t *cmd, **back;
if( !cmd_name || !*cmd_name )
return;
back = &cmd_functions;
cmd_t **back = &cmd_functions;
while( 1 )
{
cmd = *back;
cmd_t *cmd = *back;
if( !cmd ) return;
if( !Q_strcmp( cmd_name, cmd->name ))
@@ -743,20 +728,17 @@ Cmd_LookupCmds
*/
void Cmd_LookupCmds( void *buffer, void *ptr, setpair_t callback )
{
cmd_t *cmd;
cmdalias_t *alias;
// nothing to process ?
if( !callback ) return;
for( cmd = cmd_functions; cmd; cmd = cmd->next )
for( cmd_t *cmd = cmd_functions; cmd; cmd = cmd->next )
{
if( !buffer ) callback( cmd->name, (char *)cmd->function, cmd->desc, ptr );
else callback( cmd->name, (char *)cmd->function, buffer, ptr );
}
// lookup an aliases too
for( alias = cmd_alias; alias; alias = alias->next )
for( cmdalias_t *alias = cmd_alias; alias; alias = alias->next )
callback( alias->name, alias->value, buffer, ptr );
}
@@ -846,7 +828,6 @@ static void Cmd_Else_f( void )
static qboolean Cmd_ShouldAllowCommand( cmd_t *cmd, qboolean isPrivileged )
{
const char *prefixes[] = { "cl_", "gl_", "r_", "m_", "hud_", "joy_", "con_", "scr_" };
int i;
// always allow local commands
if( isPrivileged )
@@ -863,7 +844,7 @@ static qboolean Cmd_ShouldAllowCommand( cmd_t *cmd, qboolean isPrivileged )
if( FBitSet( cmd->flags, CMD_FILTERABLE ))
return false;
for( i = 0; i < ARRAYSIZE( prefixes ); i++ )
for( int i = 0; i < ARRAYSIZE( prefixes ); i++ )
{
if( !Q_strnicmp( cmd->name, prefixes[i], Q_strlen( prefixes[i] )))
return false;
@@ -1038,7 +1019,6 @@ Cmd_List_f
*/
static void Cmd_List_f( void )
{
cmd_t *cmd;
int i = 0;
size_t matchlen = 0;
const char *match = NULL;
@@ -1049,7 +1029,7 @@ static void Cmd_List_f( void )
matchlen = Q_strlen( match );
}
for( cmd = cmd_functions; cmd; cmd = cmd->next )
for( cmd_t *cmd = cmd_functions; cmd; cmd = cmd->next )
{
if( cmd->name[0] == '@' )
continue; // never show system cmds
@@ -1073,8 +1053,6 @@ unlink all commands with specified flag
*/
void Cmd_Unlink( int group )
{
cmd_t *cmd;
cmd_t **prev;
int count = 0;
if( FBitSet( group, CMD_SERVERDLL ) && Cvar_VariableInteger( "host_gameloaded" ))
@@ -1086,11 +1064,11 @@ void Cmd_Unlink( int group )
if( FBitSet( group, CMD_GAMEUIDLL ) && Cvar_VariableInteger( "host_gameuiloaded" ))
return;
prev = &cmd_functions;
cmd_t **prev = &cmd_functions;
while( 1 )
{
cmd = *prev;
cmd_t *cmd = *prev;
if( !cmd ) break;
// do filter by specified group
@@ -1115,10 +1093,6 @@ void Cmd_Unlink( int group )
static void Cmd_Apropos_f( void )
{
cmd_t *cmd;
convar_t *var;
cmdalias_t *alias;
const char *partial;
int count = 0;
char buf[MAX_VA_STRING];
@@ -1128,7 +1102,7 @@ static void Cmd_Apropos_f( void )
return;
}
partial = Cmd_Args();
const char *partial = Cmd_Args();
if( !Q_strpbrk( partial, "*?" ))
{
@@ -1136,7 +1110,7 @@ static void Cmd_Apropos_f( void )
partial = buf;
}
for( var = (convar_t*)Cvar_GetList(); var; var = var->next )
for( convar_t *var = (convar_t*)Cvar_GetList(); var; var = var->next )
{
if( !matchpattern_with_separator( var->name, partial, true, "", false ) )
{
@@ -1162,7 +1136,7 @@ static void Cmd_Apropos_f( void )
count++;
}
for( cmd = Cmd_GetFirstFunctionHandle(); cmd; cmd = Cmd_GetNextFunctionHandle( cmd ) )
for( cmd_t *cmd = Cmd_GetFirstFunctionHandle(); cmd; cmd = Cmd_GetNextFunctionHandle( cmd ) )
{
if( cmd->name[0] == '@' )
continue; // never show system cmds
@@ -1175,7 +1149,7 @@ static void Cmd_Apropos_f( void )
count++;
}
for( alias = Cmd_AliasGetList(); alias; alias = alias->next )
for( cmdalias_t *alias = Cmd_AliasGetList(); alias; alias = alias->next )
{
// proceed a bit differently here as an alias value always got a final \n
if( !matchpattern_with_separator( alias->name, partial, true, "", false ) &&
@@ -1247,10 +1221,9 @@ Cmd_ExecScript
*/
static void Cmd_ExecScript( const char *filename )
{
byte *f;
fs_offset_t len;
byte *f = FS_LoadFile( filename, &len, false );
f = FS_LoadFile( filename, &len, false );
if( !f )
{
Con_Reportf( "couldn't exec %s\n", filename );

164
engine/common/common.c
View File

@@ -68,19 +68,17 @@ static int idum = 0;
static int lran1( void )
{
static int iy = 0;
static int iv[NTAB];
int j;
int k;
static int iy = 0;
static int iv[NTAB];
if( idum <= 0 || !iy )
{
if( -(idum) < 1 ) idum = 1;
else idum = -(idum);
for( j = NTAB + 7; j >= 0; j-- )
for( int j = NTAB + 7; j >= 0; j-- )
{
k = (idum) / IQ;
int k = (idum) / IQ;
idum = IA * (idum - k * IQ) - IR * k;
if( idum < 0 ) idum += IM;
if( j < NTAB ) iv[j] = idum;
@@ -89,10 +87,10 @@ static int lran1( void )
iy = iv[0];
}
k = (idum) / IQ;
int k = (idum) / IQ;
idum = IA * (idum - k * IQ) - IR * k;
if( idum < 0 ) idum += IM;
j = iy / NDIV;
int j = iy / NDIV;
iy = iv[j];
iv[j] = idum;
@@ -121,18 +119,15 @@ void GAME_EXPORT COM_SetRandomSeed( int lSeed )
float GAME_EXPORT COM_RandomFloat( float flLow, float flHigh )
{
float fl;
if( idum == 0 ) COM_SetRandomSeed( 0 );
fl = fran1(); // float in [0,1]
float fl = fran1(); // float in [0,1]
return (fl * (flHigh - flLow)) + flLow; // float in [low, high)
}
int GAME_EXPORT COM_RandomLong( int lLow, int lHigh )
{
dword maxAcceptable;
dword n, x = lHigh - lLow + 1;
dword x = lHigh - lLow + 1;
if( idum == 0 ) COM_SetRandomSeed( 0 );
@@ -146,7 +141,8 @@ int GAME_EXPORT COM_RandomLong( int lLow, int lHigh )
// the average number of times through the loop is 2. For cases where x is
// much smaller than MAX_RANDOM_RANGE, the average number of times through the
// loop is very close to 1.
maxAcceptable = MAX_RANDOM_RANGE - ((MAX_RANDOM_RANGE + 1) % x );
dword maxAcceptable = MAX_RANDOM_RANGE - ((MAX_RANDOM_RANGE + 1) % x );
dword n;
do
{
n = lran1();
@@ -166,12 +162,13 @@ of all text functions.
*/
char *va( const char *format, ... )
{
va_list argptr;
static char string[16][MAX_VA_STRING], *s;
static int stringindex = 0;
static char string[16][MAX_VA_STRING], *s;
static int stringindex = 0;
s = string[stringindex];
stringindex = (stringindex + 1) & 15;
va_list argptr;
va_start( argptr, format );
Q_vsnprintf( s, sizeof( string[0] ), format, argptr );
va_end( argptr );
@@ -222,12 +219,10 @@ typedef struct
qboolean LZSS_IsCompressed( const byte *source, size_t input_len )
{
const lzss_header_t *phdr;
if( input_len <= sizeof( lzss_header_t ))
return 0;
phdr = (const lzss_header_t *)source;
const lzss_header_t *phdr = (const lzss_header_t *)source;
if( phdr && phdr->id == LittleLong( LZSS_ID ))
return true;
@@ -236,12 +231,10 @@ qboolean LZSS_IsCompressed( const byte *source, size_t input_len )
uint LZSS_GetActualSize( const byte *source, size_t input_len )
{
const lzss_header_t *phdr;
if( input_len <= sizeof( lzss_header_t ))
return 0;
phdr = (const lzss_header_t *)source;
const lzss_header_t *phdr = (const lzss_header_t *)source;
if( phdr && phdr->id == LittleLong( LZSS_ID ))
return LittleLong( phdr->size );
@@ -251,15 +244,12 @@ uint LZSS_GetActualSize( const byte *source, size_t input_len )
static void LZSS_BuildHash( lzss_state_t *state, const byte *source )
{
lzss_list_t *list;
lzss_node_t *node;
unsigned int targetindex = (uintptr_t)source & ( state->window_size - 1 );
node = &state->hash_node[targetindex];
unsigned int targetindex = (uintptr_t)source & ( state->window_size - 1 );
lzss_node_t *node = &state->hash_node[targetindex];
if( node->data )
{
list = &state->hash_table[*node->data];
lzss_list_t *list = &state->hash_table[*node->data];
if( node->prev )
{
list->end = node->prev;
@@ -272,7 +262,7 @@ static void LZSS_BuildHash( lzss_state_t *state, const byte *source )
}
}
list = &state->hash_table[*source];
lzss_list_t *list = &state->hash_table[*source];
node->data = source;
node->prev = NULL;
node->next = list->start;
@@ -284,19 +274,19 @@ static void LZSS_BuildHash( lzss_state_t *state, const byte *source )
static byte *LZSS_CompressNoAlloc( lzss_state_t *state, byte *pInput, int input_length, byte *pOutputBuf, uint *pOutputSize )
{
byte *pStart = pOutputBuf; // allocate the output buffer, compressed buffer is expected to be less, caller will free
byte *pEnd = pStart + input_length - sizeof( lzss_header_t ) - 8; // prevent compression failure
lzss_header_t *header = (lzss_header_t *)pStart;
byte *pOutput = pStart + sizeof( lzss_header_t );
const byte *pEncodedPosition = NULL;
byte *pLookAhead = pInput;
byte *pWindow = pInput;
int i, putCmdByte = 0;
byte *pCmdByte = NULL;
if( input_length <= sizeof( lzss_header_t ) + 8 )
return NULL;
byte *pStart = pOutputBuf; // allocate the output buffer, compressed buffer is expected to be less, caller will free
byte *pEnd = pStart + input_length - sizeof( lzss_header_t ) - 8; // prevent compression failure
lzss_header_t *header = (lzss_header_t *)pStart;
byte *pOutput = pStart + sizeof( lzss_header_t );
const byte *pEncodedPosition = NULL;
byte *pLookAhead = pInput;
byte *pWindow = pInput;
int putCmdByte = 0;
byte *pCmdByte = NULL;
// set LZSS header
header->id = LittleLong( LZSS_ID );
header->size = LittleLong( input_length );
@@ -359,7 +349,7 @@ static byte *LZSS_CompressNoAlloc( lzss_state_t *state, byte *pInput, int input_
encoded_length = 1;
}
for( i = 0; i < encoded_length; i++ )
for( int i = 0; i < encoded_length; i++ )
{
LZSS_BuildHash( state, pLookAhead++ );
}
@@ -407,13 +397,12 @@ static byte *LZSS_CompressNoAlloc( lzss_state_t *state, byte *pInput, int input_
byte *LZSS_Compress( byte *pInput, int inputLength, uint *pOutputSize )
{
byte *pStart = (byte *)malloc( inputLength );
byte *pFinal = NULL;
lzss_state_t state = { .window_size = LZSS_WINDOW_SIZE };
if( !pStart )
return NULL;
pFinal = LZSS_CompressNoAlloc( &state, pInput, inputLength, pStart, pOutputSize );
lzss_state_t state = { .window_size = LZSS_WINDOW_SIZE };
byte *pFinal = LZSS_CompressNoAlloc( &state, pInput, inputLength, pStart, pOutputSize );
if( !pFinal )
{
@@ -426,21 +415,20 @@ byte *LZSS_Compress( byte *pInput, int inputLength, uint *pOutputSize )
uint LZSS_Decompress( const byte *pInput, byte *pOutput, size_t input_len, size_t output_len )
{
uint totalBytes = 0;
int getCmdByte = 0;
int cmdByte = 0;
uint actualSize;
const byte *pInputEnd = pInput + input_len - 1; // thanks to nillerusr for the fix!
byte *pOrigOutput = pOutput;
if( input_len <= sizeof( lzss_header_t ))
return 0;
actualSize = LZSS_GetActualSize( pInput, input_len );
uint actualSize = LZSS_GetActualSize( pInput, input_len );
if( !actualSize || actualSize > output_len )
return 0;
uint totalBytes = 0;
int getCmdByte = 0;
int cmdByte = 0;
const byte *pInputEnd = pInput + input_len - 1; // thanks to nillerusr for the fix!
byte *pOrigOutput = pOutput;
pInput += sizeof( lzss_header_t );
while( 1 )
@@ -456,26 +444,22 @@ uint LZSS_Decompress( const byte *pInput, byte *pOutput, size_t input_len, size_
if( cmdByte & 0x01 )
{
int position;
int i, count;
byte *pSource;
if( pInput > pInputEnd )
return 0;
position = *pInput++ << LZSS_LOOKSHIFT;
int position = *pInput++ << LZSS_LOOKSHIFT;
position |= ( *pInput >> LZSS_LOOKSHIFT );
count = ( *pInput++ & 0x0F ) + 1;
int count = ( *pInput++ & 0x0F ) + 1;
if( count == 1 )
break;
pSource = pOutput - position - 1;
byte *pSource = pOutput - position - 1;
if( totalBytes + count > output_len || pSource < pOrigOutput )
return 0;
for( i = 0; i < count; i++ )
for( int i = 0; i < count; i++ )
*pOutput++ = *pSource++;
totalBytes += count;
}
@@ -506,16 +490,12 @@ COM_ParseVector
*/
qboolean COM_ParseVector( char **pfile, float *v, size_t size )
{
string token;
qboolean bracket = false;
char *saved;
uint i;
if( v == NULL || size == 0 )
return false;
memset( v, 0, sizeof( *v ) * size );
string token;
if( size == 1 )
{
*pfile = COM_ParseFile( *pfile, token, sizeof( token ));
@@ -523,16 +503,17 @@ qboolean COM_ParseVector( char **pfile, float *v, size_t size )
return true;
}
saved = *pfile;
char *saved = *pfile;
if(( *pfile = COM_ParseFile( *pfile, token, sizeof( token ))) == NULL )
return false;
qboolean bracket = false;
if( token[0] == '(' )
bracket = true;
else *pfile = saved; // restore token to right get it again
for( i = 0; i < size; i++ )
for( uint i = 0; i < size; i++ )
{
*pfile = COM_ParseFile( *pfile, token, sizeof( token ));
v[i] = Q_atof( token );
@@ -595,13 +576,11 @@ Converts pszInput Hex string to nInputLength/2 binary
*/
void COM_HexConvert( const char *pszInput, int nInputLength, byte *pOutput )
{
const char *pIn;
byte *p = pOutput;
int i;
byte *p = pOutput;
for( i = 0; i < nInputLength; i += 2 )
for( int i = 0; i < nInputLength; i += 2 )
{
pIn = &pszInput[i];
const char *pIn = &pszInput[i];
*p = COM_Nibble( pIn[0] ) << 4 | COM_Nibble( pIn[1] );
p++;
}
@@ -615,10 +594,6 @@ COM_LoadFileForMe
*/
byte *GAME_EXPORT COM_LoadFileForMe( const char *filename, int *pLength )
{
string name;
byte *pfile;
fs_offset_t iLength;
if( COM_StringEmptyOrNULL( filename ))
{
if( pLength )
@@ -626,10 +601,12 @@ byte *GAME_EXPORT COM_LoadFileForMe( const char *filename, int *pLength )
return NULL;
}
string name;
Q_strncpy( name, filename, sizeof( name ));
COM_FixSlashes( name );
pfile = g_fsapi.LoadFileMalloc( name, &iLength, false );
fs_offset_t iLength;
byte *pfile = g_fsapi.LoadFileMalloc( name, &iLength, false );
if( pLength ) *pLength = (int)iLength;
return pfile;
@@ -728,16 +705,17 @@ pfnCompareFileTime
*/
int GAME_EXPORT pfnCompareFileTime( const char *path1, const char *path2, int *retval )
{
int t1, t2;
*retval = 0;
if( !path1 || !path2 )
return 0;
if(( t1 = g_fsapi.FileTime( path1, false )) == -1 )
int t1 = g_fsapi.FileTime( path1, false );
if( t1 == -1 )
return 0;
if(( t2 = g_fsapi.FileTime( path2, false )) == -1 )
int t2 = g_fsapi.FileTime( path2, false );
if( t2 == -1 )
return 0;
if( t1 < t2 )
@@ -770,17 +748,11 @@ int GAME_EXPORT COM_CheckParm( char *parm, char **ppnext )
qboolean COM_IsSafeFileToDownload( const char *filename )
{
char lwrfilename[4096];
const char *last;
const char *ext;
size_t len;
int i;
if( COM_StringEmptyOrNULL( filename ))
return false;
ext = COM_FileExtension( filename );
len = Q_strlen( filename );
const char *ext = COM_FileExtension( filename );
size_t len = Q_strlen( filename );
// only allow extensionless files that start with !MD5
if( !Q_strncmp( filename, "!MD5", 4 ))
@@ -793,7 +765,7 @@ qboolean COM_IsSafeFileToDownload( const char *filename )
if( len != 36 )
return false;
for( i = 4; i < len; i++ )
for( int i = 4; i < len; i++ )
{
if(( filename[i] >= '0' && filename[i] <= '9' ) ||
( filename[i] >= 'A' && filename[i] <= 'F' ))
@@ -805,12 +777,13 @@ qboolean COM_IsSafeFileToDownload( const char *filename )
return true;
}
for( i = 0; i < len; i++ )
for( int i = 0; i < len; i++ )
{
if( !isprint( filename[i] ))
return false;
}
char lwrfilename[4096];
Q_strnlwr( filename, lwrfilename, sizeof( lwrfilename ));
ext = COM_FileExtension( lwrfilename );
@@ -820,7 +793,7 @@ qboolean COM_IsSafeFileToDownload( const char *filename )
if( lwrfilename[0] == '/' )
return false;
last = Q_strrchr( lwrfilename, '.' );
const char *last = Q_strrchr( lwrfilename, '.' );
if( last == NULL )
return false;
@@ -828,7 +801,7 @@ qboolean COM_IsSafeFileToDownload( const char *filename )
if( Q_strlen( last ) != 4 )
return false;
for( i = 0; i < ARRAYSIZE( file_exts ); i++ )
for( int i = 0; i < ARRAYSIZE( file_exts ); i++ )
{
if( !Q_stricmp( ext, file_exts[i] ))
return false;
@@ -839,14 +812,11 @@ qboolean COM_IsSafeFileToDownload( const char *filename )
char *_copystring( poolhandle_t mempool, const char *s, const char *filename, int fileline )
{
size_t size;
char *b;
if( !s ) return NULL;
if( !mempool ) mempool = host.mempool;
size = Q_strlen( s ) + 1;
b = _Mem_Alloc( mempool, size, false, filename, fileline );
size_t size = Q_strlen( s ) + 1;
char *b = _Mem_Alloc( mempool, size, false, filename, fileline );
Q_strncpy( b, s, size );
return b;

239
engine/common/con_utils.c
View File

@@ -54,11 +54,10 @@ Cmd_ListMaps
*/
int Cmd_ListMaps( search_t *t, char *lastmapname, size_t len, qboolean silent )
{
file_t *f;
int i, nummaps;
int nummaps = 0;
string mapname, message, compiler, generator;
for( i = 0, nummaps = 0; i < t->numfilenames; i++ )
for( int i = 0; i < t->numfilenames; i++ )
{
char entfilename[MAX_QPATH];
const char *ext = COM_FileExtension( t->filenames[i] );
@@ -72,17 +71,14 @@ int Cmd_ListMaps( search_t *t, char *lastmapname, size_t len, qboolean silent )
compiler[0] = '\0';
generator[0] = '\0';
f = FS_Open( t->filenames[i], "rb", con_gamemaps.value );
file_t *f = FS_Open( t->filenames[i], "rb", con_gamemaps.value );
if( f )
{
dheader_t *header;
dextrahdr_t *hdrext;
dlump_t entities;
fs_offset_t filelen;
byte buf[MAX_SYSPATH] = { 0 }; // 1 kb
filelen = FS_Read( f, buf, sizeof( buf ));
fs_offset_t filelen = FS_Read( f, buf, sizeof( buf ));
// check all the lumps and some other errors
if( !Mod_TestBmodelLumps( f, t->filenames[i], buf, filelen, silent, &entities ))
@@ -94,8 +90,8 @@ int Cmd_ListMaps( search_t *t, char *lastmapname, size_t len, qboolean silent )
lumpofs = entities.fileofs;
lumplen = entities.filelen;
header = (dheader_t *)buf;
hdrext = (dextrahdr_t *)((byte *)buf + sizeof( dheader_t ));
dheader_t *header = (dheader_t *)buf;
dextrahdr_t *hdrext = (dextrahdr_t *)((byte *)buf + sizeof( dheader_t ));
ver = header->version;
if( hdrext->id == IDEXTRAHEADER ) version = hdrext->version;
@@ -187,11 +183,9 @@ Prints or complete map filename
*/
static qboolean Cmd_GetMapList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, nummaps;
string matchbuf;
t = FS_Search( va( "maps/%s*.bsp", s ), true, con_gamemaps.value );
search_t *t = FS_Search( va( "maps/%s*.bsp", s ), true, con_gamemaps.value );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -199,7 +193,7 @@ static qboolean Cmd_GetMapList( const char *s, char *completedname, int length,
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
nummaps = Cmd_ListMaps( t, matchbuf, sizeof( matchbuf ), !print_suggestions );
int nummaps = Cmd_ListMaps( t, matchbuf, sizeof( matchbuf ), !print_suggestions );
if( print_suggestions )
Con_Printf( "\n^3 %d maps found.\n", nummaps );
@@ -207,7 +201,7 @@ static qboolean Cmd_GetMapList( const char *s, char *completedname, int length,
Mem_Free( t );
// cut shortestMatch to the amount common with s
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -224,12 +218,10 @@ Prints or complete demo filename
*/
static qboolean Cmd_GetDemoList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, numdems;
string matchbuf;
// lookup only in gamedir
t = FS_Search( va( "%s*.dem", s ), true, true );
search_t *t = FS_Search( va( "%s*.dem", s ), true, true );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -237,7 +229,8 @@ static qboolean Cmd_GetDemoList( const char *s, char *completedname, int length,
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for( i = 0, numdems = 0; i < t->numfilenames; i++ )
int numdems = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
if( Q_stricmp( COM_FileExtension( t->filenames[i] ), "dem" ))
continue;
@@ -256,7 +249,7 @@ static qboolean Cmd_GetDemoList( const char *s, char *completedname, int length,
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -274,11 +267,9 @@ Prints or complete movie filename
*/
static qboolean Cmd_GetMovieList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, nummovies;
string matchbuf;
t = FS_Search( va( "media/%s*.avi", s ), true, false );
search_t *t = FS_Search( va( "media/%s*.avi", s ), true, false );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -286,7 +277,8 @@ static qboolean Cmd_GetMovieList( const char *s, char *completedname, int length
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for(i = 0, nummovies = 0; i < t->numfilenames; i++)
int nummovies = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
if( Q_stricmp( COM_FileExtension( t->filenames[i] ), "avi" ))
continue;
@@ -304,7 +296,7 @@ static qboolean Cmd_GetMovieList( const char *s, char *completedname, int length
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -323,11 +315,9 @@ Prints or complete background track filename
*/
static qboolean Cmd_GetMusicList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, numtracks;
string matchbuf;
t = FS_Search( va( "media/%s*.*", s ), true, false );
search_t *t = FS_Search( va( "media/%s*.*", s ), true, false );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -335,7 +325,8 @@ static qboolean Cmd_GetMusicList( const char *s, char *completedname, int length
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for(i = 0, numtracks = 0; i < t->numfilenames; i++)
int numtracks = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
const char *ext = COM_FileExtension( t->filenames[i] );
@@ -355,7 +346,7 @@ static qboolean Cmd_GetMusicList( const char *s, char *completedname, int length
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -373,11 +364,9 @@ Prints or complete savegame filename
*/
static qboolean Cmd_GetSavesList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, numsaves;
string matchbuf;
t = FS_Search( va( DEFAULT_SAVE_DIRECTORY "%s*.sav", s ), true, true ); // lookup only in gamedir
search_t *t = FS_Search( va( DEFAULT_SAVE_DIRECTORY "%s*.sav", s ), true, true ); // lookup only in gamedir
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -385,7 +374,8 @@ static qboolean Cmd_GetSavesList( const char *s, char *completedname, int length
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for( i = 0, numsaves = 0; i < t->numfilenames; i++ )
int numsaves = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
if( Q_stricmp( COM_FileExtension( t->filenames[i] ), "sav" ))
continue;
@@ -403,7 +393,7 @@ static qboolean Cmd_GetSavesList( const char *s, char *completedname, int length
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -422,11 +412,9 @@ Prints or complete .cfg filename
*/
static qboolean Cmd_GetConfigList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, numconfigs;
string matchbuf;
t = FS_Search( va( "%s*.cfg", s ), true, false );
search_t *t = FS_Search( va( "%s*.cfg", s ), true, false );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -434,7 +422,8 @@ static qboolean Cmd_GetConfigList( const char *s, char *completedname, int lengt
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for( i = 0, numconfigs = 0; i < t->numfilenames; i++ )
int numconfigs = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
if( Q_stricmp( COM_FileExtension( t->filenames[i] ), "cfg" ))
continue;
@@ -452,7 +441,7 @@ static qboolean Cmd_GetConfigList( const char *s, char *completedname, int lengt
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -471,11 +460,9 @@ Prints or complete sound filename
*/
static qboolean Cmd_GetSoundList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, numsounds;
string matchbuf;
t = FS_Search( va( "%s%s*.*", DEFAULT_SOUNDPATH, s ), true, false );
search_t *t = FS_Search( va( "%s%s*.*", DEFAULT_SOUNDPATH, s ), true, false );
if( !t ) return false;
Q_strncpy( matchbuf, t->filenames[0] + sizeof( DEFAULT_SOUNDPATH ) - 1, sizeof( matchbuf ));
@@ -484,7 +471,8 @@ static qboolean Cmd_GetSoundList( const char *s, char *completedname, int length
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for(i = 0, numsounds = 0; i < t->numfilenames; i++)
int numsounds = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
const char *ext = COM_FileExtension( t->filenames[i] );
@@ -505,7 +493,7 @@ static qboolean Cmd_GetSoundList( const char *s, char *completedname, int length
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -525,12 +513,10 @@ Prints or complete item classname (weapons only)
static qboolean Cmd_GetItemsList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
#if !XASH_DEDICATED
search_t *t;
string matchbuf;
int i, numitems;
string matchbuf;
if( !clgame.itemspath[0] ) return false; // not in game yet
t = FS_Search( va( "%s/%s*.txt", clgame.itemspath, s ), true, false );
search_t *t = FS_Search( va( "%s/%s*.txt", clgame.itemspath, s ), true, false );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -538,7 +524,8 @@ static qboolean Cmd_GetItemsList( const char *s, char *completedname, int length
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for( i = 0, numitems = 0; i < t->numfilenames; i++ )
int numitems = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
if( Q_stricmp( COM_FileExtension( t->filenames[i] ), "txt" ))
continue;
@@ -556,7 +543,7 @@ static qboolean Cmd_GetItemsList( const char *s, char *completedname, int length
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -612,7 +599,6 @@ Autocomplete for bind command
*/
static qboolean Cmd_GetCommandsAndCvarsList( const char *s, char *completedname, int length, qboolean cmds, qboolean cvars, qboolean toggle, qboolean print_suggestions )
{
size_t i;
string matchbuf;
con_autocomplete_t list = { 0 }; // local autocomplete list
@@ -645,7 +631,7 @@ static qboolean Cmd_GetCommandsAndCvarsList( const char *s, char *completedname,
qsort( list.cmds, list.matchCount, sizeof( char* ), Con_SortCmds );
for( i = 0; i < list.matchCount; i++ )
for( size_t i = 0; i < list.matchCount; i++ )
{
Q_strncpy( matchbuf, list.cmds[i], sizeof( matchbuf ));
if( print_suggestions )
@@ -657,14 +643,14 @@ static qboolean Cmd_GetCommandsAndCvarsList( const char *s, char *completedname,
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( size_t i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
}
}
for( i = 0; i < list.matchCount; i++ )
for( size_t i = 0; i < list.matchCount; i++ )
{
if( list.cmds[i] != NULL )
{
@@ -709,11 +695,9 @@ Prints or complete .HPK filenames
*/
static qboolean Cmd_GetCustomList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
search_t *t;
string matchbuf;
int i, numitems;
string matchbuf;
t = FS_Search( va( "%s*.hpk", s ), true, false );
search_t *t = FS_Search( va( "%s*.hpk", s ), true, false );
if( !t ) return false;
COM_FileBase( t->filenames[0], matchbuf, sizeof( matchbuf ));
@@ -721,7 +705,8 @@ static qboolean Cmd_GetCustomList( const char *s, char *completedname, int lengt
Q_strncpy( completedname, matchbuf, length );
if( t->numfilenames == 1 ) return true;
for(i = 0, numitems = 0; i < t->numfilenames; i++)
int numitems = 0;
for( int i = 0; i < t->numfilenames; i++ )
{
if( Q_stricmp( COM_FileExtension( t->filenames[i] ), "hpk" ))
continue;
@@ -739,7 +724,7 @@ static qboolean Cmd_GetCustomList( const char *s, char *completedname, int lengt
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -757,15 +742,14 @@ Prints or complete gamedir name
*/
static qboolean Cmd_GetGamesList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
int i, numgamedirs;
string gamedirs[MAX_MODS];
string matchbuf;
int len;
string gamedirs[MAX_MODS];
string matchbuf;
// compare gamelist with current keyword
len = Q_strlen( s );
int len = Q_strlen( s );
for( i = 0, numgamedirs = 0; i < FI->numgames; i++ )
int numgamedirs = 0;
for( int i = 0; i < FI->numgames; i++ )
{
if(( *s == '*' ) || !Q_strnicmp( FI->games[i]->gamefolder, s, len))
Q_strncpy( gamedirs[numgamedirs++], FI->games[i]->gamefolder, sizeof( gamedirs[0] ));
@@ -777,7 +761,7 @@ static qboolean Cmd_GetGamesList( const char *s, char *completedname, int length
Q_strncpy( completedname, matchbuf, length );
if( numgamedirs == 1 ) return true;
for( i = 0; i < numgamedirs; i++ )
for( int i = 0; i < numgamedirs; i++ )
{
Q_strncpy( matchbuf, gamedirs[i], sizeof( matchbuf ));
if( print_suggestions )
@@ -790,7 +774,7 @@ static qboolean Cmd_GetGamesList( const char *s, char *completedname, int length
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -808,10 +792,8 @@ Prints or complete CD command name
*/
static qboolean Cmd_GetCDList( const char *s, char *completedname, int length, qboolean print_suggestions )
{
int i, numcdcommands;
string cdcommands[8];
string matchbuf;
int len;
string cdcommands[8];
string matchbuf;
const char *cd_command[] =
{
@@ -826,9 +808,10 @@ static qboolean Cmd_GetCDList( const char *s, char *completedname, int length, q
};
// compare CD command list with current keyword
len = Q_strlen( s );
int len = Q_strlen( s );
for( i = 0, numcdcommands = 0; i < 8; i++ )
int numcdcommands = 0;
for( int i = 0; i < 8; i++ )
{
if(( *s == '*' ) || !Q_strnicmp( cd_command[i], s, len))
Q_strncpy( cdcommands[numcdcommands++], cd_command[i], sizeof( cdcommands[0] ));
@@ -840,7 +823,7 @@ static qboolean Cmd_GetCDList( const char *s, char *completedname, int length, q
Q_strncpy( completedname, matchbuf, length );
if( numcdcommands == 1 ) return true;
for( i = 0; i < numcdcommands; i++ )
for( int i = 0; i < numcdcommands; i++ )
{
Q_strncpy( matchbuf, cdcommands[i], sizeof( matchbuf ));
if( print_suggestions )
@@ -853,7 +836,7 @@ static qboolean Cmd_GetCDList( const char *s, char *completedname, int length, q
// cut shortestMatch to the amount common with s
if( completedname && length )
{
for( i = 0; matchbuf[i]; i++ )
for( int i = 0; matchbuf[i]; i++ )
{
if( Q_tolower( completedname[i] ) != Q_tolower( matchbuf[i] ))
completedname[i] = 0;
@@ -864,21 +847,15 @@ static qboolean Cmd_GetCDList( const char *s, char *completedname, int length, q
static qboolean Cmd_CheckMapsList_R( qboolean fRefresh, qboolean onlyingamedir )
{
qboolean use_filter = false;
string mpfilter;
char *buffer;
size_t buffersize;
string result;
int i, size;
search_t *t;
file_t *f;
string mpfilter;
string result;
if( FS_FileSize( "maps.lst", onlyingamedir ) > 0 && !fRefresh )
return true; // exist
// setup mpfilter
Q_snprintf( mpfilter, sizeof( mpfilter ), "maps/%s", GI->mp_filter );
t = FS_Search( "maps/*.bsp", false, onlyingamedir );
search_t *t = FS_Search( "maps/*.bsp", false, onlyingamedir );
if( !t )
{
@@ -890,11 +867,11 @@ static qboolean Cmd_CheckMapsList_R( qboolean fRefresh, qboolean onlyingamedir )
return false;
}
buffersize = t->numfilenames * 2 * sizeof( result );
buffer = Mem_Calloc( host.mempool, buffersize );
use_filter = !COM_StringEmpty( GI->mp_filter );
size_t buffersize = t->numfilenames * 2 * sizeof( result );
char *buffer = Mem_Calloc( host.mempool, buffersize );
qboolean use_filter = !COM_StringEmpty( GI->mp_filter );
for( i = 0; i < t->numfilenames; i++ )
for( int i = 0; i < t->numfilenames; i++ )
{
char *ents = NULL, *pfile;
int lumpofs = 0, lumplen = 0;
@@ -906,17 +883,16 @@ static qboolean Cmd_CheckMapsList_R( qboolean fRefresh, qboolean onlyingamedir )
if( use_filter && Q_stristr( t->filenames[i], mpfilter ))
continue;
f = FS_Open( t->filenames[i], "rb", onlyingamedir );
file_t *f = FS_Open( t->filenames[i], "rb", onlyingamedir );
COM_FileBase( t->filenames[i], mapname, sizeof( mapname ));
if( f )
{
qboolean have_spawnpoints = false;
dlump_t entities;
fs_offset_t filelen;
byte buf[MAX_SYSPATH] = { 0 };
filelen = FS_Read( f, buf, MAX_SYSPATH );
fs_offset_t filelen = FS_Read( f, buf, MAX_SYSPATH );
// check all the lumps and some other errors
if( !Mod_TestBmodelLumps( f, t->filenames[i], buf, filelen, true, &entities ))
@@ -999,7 +975,7 @@ static qboolean Cmd_CheckMapsList_R( qboolean fRefresh, qboolean onlyingamedir )
}
if( t ) Mem_Free( t ); // free search result
size = Q_strlen( buffer );
int size = Q_strlen( buffer );
if( !size )
{
@@ -1102,9 +1078,7 @@ for various cmds
*/
static qboolean Cmd_AutocompleteName( const char *source, int arg, char *buffer, size_t bufsize, qboolean print_suggestions )
{
int i;
for( i = 0; i < ARRAYSIZE( cmd_list ); i++ )
for( int i = 0; i < ARRAYSIZE( cmd_list ); i++ )
{
if( cmd_list[i].arg == arg && Cmd_CheckName( cmd_list[i].name ))
return cmd_list[i].func( source, buffer, bufsize, print_suggestions );
@@ -1150,14 +1124,11 @@ Con_ConcatRemaining
*/
static void Con_ConcatRemaining( const char *src, const char *start )
{
const char *arg;
int i;
arg = Q_strstr( src, start );
const char *arg = Q_strstr( src, start );
if( !arg )
{
for( i = 1; i < Cmd_Argc(); i++ )
for( int i = 1; i < Cmd_Argc(); i++ )
{
Q_strncat( con.completionField->buffer, " ", sizeof( con.completionField->buffer ) );
arg = Cmd_Argv( i );
@@ -1190,11 +1161,7 @@ perform Tab expansion
*/
void Con_CompleteCommand( field_t *field, qboolean print_suggestions )
{
field_t temp;
string filename;
qboolean toggle = false;
qboolean nextcmd;
int i;
// setup the completion field
con.completionField = field;
@@ -1205,7 +1172,7 @@ void Con_CompleteCommand( field_t *field, qboolean print_suggestions )
// only look at the first token for completion purposes
Cmd_TokenizeString( con.completionField->buffer );
nextcmd = (con.completionField->buffer[Q_strlen( con.completionField->buffer ) - 1] == ' ') ? true : false;
qboolean nextcmd = (con.completionField->buffer[Q_strlen( con.completionField->buffer ) - 1] == ' ') ? true : false;
con.completionString = Cmd_Argv( 0 );
@@ -1217,7 +1184,7 @@ void Con_CompleteCommand( field_t *field, qboolean print_suggestions )
return;
// free the old autocomplete list
for( i = 0; i < con.matchCount; i++ )
for( int i = 0; i < con.matchCount; i++ )
{
if( con.cmds[i] != NULL )
{
@@ -1235,7 +1202,7 @@ void Con_CompleteCommand( field_t *field, qboolean print_suggestions )
if( !con.matchCount ) return; // no matches
temp = *con.completionField;
field_t temp = *con.completionField;
// autocomplete second arg
if(( Cmd_Argc() >= 2 ) || ( Cmd_Argc() == 1 && nextcmd ))
@@ -1249,11 +1216,12 @@ void Con_CompleteCommand( field_t *field, qboolean print_suggestions )
if( COM_StringEmpty( con.completionBuffer ) )
return;
string filename;
if( Cmd_AutocompleteName( con.completionBuffer, Cmd_Argc() - 1, filename, sizeof( filename ), print_suggestions ))
{
con.completionField->buffer[0] = 0;
for( i = 0; i < Cmd_Argc() - 1; i++ )
for( int i = 0; i < Cmd_Argc() - 1; i++ )
{
Q_strncat( con.completionField->buffer, Cmd_Argv( i ), sizeof( con.completionField->buffer ));
Q_strncat( con.completionField->buffer, " ", sizeof( con.completionField->buffer ));
@@ -1320,12 +1288,11 @@ NOTE: input string must be equal or longer than MAX_STRING
*/
void Cmd_AutoComplete( char *complete_string )
{
field_t input;
if( !complete_string || !*complete_string )
return;
// setup input
field_t input;
Q_strncpy( input.buffer, complete_string, sizeof( input.buffer ) );
input.cursor = input.scroll = 0;
@@ -1345,10 +1312,8 @@ Cmd_AutoCompleteClear
*/
void Cmd_AutoCompleteClear( void )
{
int i;
// free the old autocomplete list
for( i = 0; i < con.matchCount; i++ )
for( int i = 0; i < con.matchCount; i++ )
{
if( con.cmds[i] != NULL )
{
@@ -1377,15 +1342,13 @@ static void Cmd_WriteOpenGLCvar( const char *name, const char *string, const cha
static void Cmd_WriteHelp(const char *name, const char *unused, const char *desc, void *f )
{
int length;
if( COM_StringEmptyOrNULL( desc ))
return; // ignore fantom cmds
if( name[0] == '+' || name[0] == '-' )
return; // key bindings
length = 3 - (Q_strlen( name ) / 10); // Asm_Ed default tab stop is 10
int length = 3 - (Q_strlen( name ) / 10); // Asm_Ed default tab stop is 10
if( length == 3 ) FS_Printf( f, "%s\t\t\t\"%s\"\n", name, desc );
if( length == 2 ) FS_Printf( f, "%s\t\t\"%s\"\n", name, desc );
@@ -1431,14 +1394,13 @@ Writes key bindings and archived cvars to config.cfg
*/
void Host_WriteConfig( void )
{
kbutton_t *mlook = NULL;
kbutton_t *jlook = NULL;
file_t *f;
kbutton_t *mlook = NULL;
kbutton_t *jlook = NULL;
if( !clgame.hInstance || Sys_CheckParm( "-nowriteconfig" ) ) return;
f = FS_Open( "config.cfg.new", "w", false );
file_t *f = FS_Open( "config.cfg.new", "w", false );
if( f )
{
Con_Reportf( "%s()\n", __func__ );
@@ -1479,11 +1441,11 @@ save serverinfo variables into server.cfg (using for dedicated server too)
*/
void GAME_EXPORT Host_WriteServerConfig( const char *name )
{
file_t *f;
string newconfigfile;
Q_snprintf( newconfigfile, MAX_STRING, "%s.new", name );
file_t *f;
if(( f = FS_Open( newconfigfile, "w", false )) != NULL )
{
Host_InitializeConfig( f, "game.cfg", "multiplayer server temporary config" );
@@ -1504,21 +1466,18 @@ save opengl variables into opengl.cfg
*/
void Host_WriteOpenGLConfig( void )
{
const char *config_name;
string name;
file_t *f;
if( Sys_CheckParm( "-nowriteconfig" ) || !ref.dllFuncs.R_GetConfigName )
return;
config_name = ref.dllFuncs.R_GetConfigName();
const char *config_name = ref.dllFuncs.R_GetConfigName();
if( !config_name )
return;
string name;
Q_snprintf( name, sizeof( name ), "%s.cfg", config_name );
f = FS_Open( va( "%s.new", name ), "w", false );
file_t *f = FS_Open( va( "%s.new", name ), "w", false );
if( f )
{
Con_Reportf( "%s()\n", __func__ );
@@ -1539,12 +1498,10 @@ save render variables into video.cfg
*/
void Host_WriteVideoConfig( void )
{
file_t *f;
if( Sys_CheckParm( "-nowriteconfig" ) )
return;
f = FS_Open( "video.cfg.new", "w", false );
file_t *f = FS_Open( "video.cfg.new", "w", false );
if( f )
{
Con_Reportf( "%s()\n", __func__ );
@@ -1558,8 +1515,6 @@ void Host_WriteVideoConfig( void )
void Key_EnumCmds_f( void )
{
file_t *f;
FS_AllowDirectPaths( true );
if( FS_FileExists( "../help.txt", false ))
{
@@ -1568,7 +1523,7 @@ void Key_EnumCmds_f( void )
return;
}
f = FS_Open( "../help.txt", "w", false );
file_t *f = FS_Open( "../help.txt", "w", false );
if( f )
{
Host_InitializeConfig( f, "help.txt", "xash commands and console variables" );

12
engine/common/custom.c
View File

@@ -51,10 +51,9 @@ static qboolean CustomDecal_Validate( const char *path, void *raw, int nFileSize
void COM_ClearCustomizationList( customization_t *pHead, qboolean bCleanDecals )
{
customization_t *pCurrent;
customization_t *pNext;
for( pCurrent = pHead->pNext; pCurrent != NULL; pCurrent = pNext )
for( customization_t *pCurrent = pHead->pNext; pCurrent != NULL; pCurrent = pNext )
{
pNext = pCurrent->pNext;
@@ -82,12 +81,10 @@ void COM_ClearCustomizationList( customization_t *pHead, qboolean bCleanDecals )
qboolean COM_CreateCustomization( customization_t *pListHead, resource_t *pResource, int playernumber, int flags, customization_t **pOut, int *nLumps )
{
qboolean bError = false;
fs_offset_t checksize = 0;
customization_t *pCust;
if( pOut ) *pOut = NULL;
pCust = Z_Calloc( sizeof( customization_t ));
customization_t *pCust = Z_Calloc( sizeof( customization_t ));
pCust->resource = *pResource;
if( pResource->nDownloadSize <= 0 )
@@ -102,7 +99,7 @@ qboolean COM_CreateCustomization( customization_t *pListHead, resource_t *pResou
}
else
{
fs_offset_t checksize = 0;
pCust->pBuffer = FS_LoadFile( pResource->szFileName, &checksize, true );
if( (int)checksize != pCust->resource.nDownloadSize )
bError = true;
@@ -158,11 +155,10 @@ CustomizationError:
int COM_SizeofResourceList( resource_t *pList, resourceinfo_t *ri )
{
int nSize = 0;
resource_t *p;
memset( ri, 0, sizeof( *ri ));
for( p = pList->pNext; p != pList; p = p->pNext )
for( resource_t *p = pList->pNext; p != pList; p = p->pNext )
{
nSize += p->nDownloadSize;

87
engine/common/cvar.c
View File

@@ -70,12 +70,10 @@ find the specified variable by name
*/
convar_t *Cvar_FindVar( const char *var_name )
{
convar_t *var;
if( !var_name )
return NULL;
var = BaseCmd_Find( HM_CVAR, var_name );
convar_t *var = BaseCmd_Find( HM_CVAR, var_name );
// HACKHACK: HL25 compatibility
if( !var && !Q_stricmp( var_name, "gl_widescreen_yfov" ))
@@ -190,10 +188,9 @@ deal with userinfo etc
*/
static const char *Cvar_ValidateString( convar_t *var, const char *value )
{
const char *pszValue;
static char szNew[MAX_STRING];
const char *pszValue = value;
pszValue = value;
szNew[0] = 0;
// this cvar's string must only contain printable characters.
@@ -283,14 +280,11 @@ unlink the variable
static int Cvar_UnlinkVar( const char *var_name, uint32_t group )
{
int count = 0;
convar_t **prev;
convar_t *var;
prev = &cvar_vars;
convar_t **prev = &cvar_vars;
while( 1 )
{
var = *prev;
convar_t *var = *prev;
if( !var ) break;
// do filter by name
@@ -358,13 +352,11 @@ Cvar_LookupVars
*/
void Cvar_LookupVars( int checkbit, void *buffer, void *ptr, setpair_t callback )
{
convar_t *var;
// nothing to process ?
if( !callback ) return;
// force checkbit to 0 for lookup all cvars
for( var = cvar_vars; var; var = var->next )
for( convar_t *var = cvar_vars; var; var = var->next )
{
if( checkbit && !FBitSet( var->flags, checkbit ))
continue;
@@ -627,8 +619,6 @@ Cvar_Set2
*/
static convar_t *Cvar_Set2( const char *var_name, const char *value )
{
convar_t *var;
qboolean dll_variable = false;
qboolean force = false;
if( !Cvar_ValidateVarName( var_name, false ))
@@ -637,7 +627,7 @@ static convar_t *Cvar_Set2( const char *var_name, const char *value )
return NULL;
}
var = Cvar_FindVar( var_name );
convar_t *var = Cvar_FindVar( var_name );
if( !var )
{
// if cvar not found, create it
@@ -663,7 +653,7 @@ static convar_t *Cvar_Set2( const char *var_name, const char *value )
// use this check to prevent acessing for unexisting fields
// for cvar_t: latched_string, description, etc
dll_variable = FBitSet( var->flags, FCVAR_EXTDLL );
qboolean dll_variable = FBitSet( var->flags, FCVAR_EXTDLL );
// check value
if( !value )
@@ -782,8 +772,6 @@ Cvar_Set
*/
void GAME_EXPORT Cvar_Set( const char *var_name, const char *value )
{
convar_t *var;
if( !var_name )
{
// there is an error in C code if this happens
@@ -791,7 +779,7 @@ void GAME_EXPORT Cvar_Set( const char *var_name, const char *value )
return;
}
var = Cvar_FindVar( var_name );
convar_t *var = Cvar_FindVar( var_name );
if( !var )
{
@@ -836,8 +824,6 @@ Cvar_VariableValue
*/
float GAME_EXPORT Cvar_VariableValue( const char *var_name )
{
convar_t *var;
if( !var_name )
{
// there is an error in C code if this happens
@@ -845,7 +831,7 @@ float GAME_EXPORT Cvar_VariableValue( const char *var_name )
return 0.0f;
}
var = Cvar_FindVar( var_name );
convar_t *var = Cvar_FindVar( var_name );
if( !var ) return 0.0f;
return Q_atof( var->string );
@@ -858,9 +844,7 @@ Cvar_VariableInteger
*/
int Cvar_VariableInteger( const char *var_name )
{
convar_t *var;
var = Cvar_FindVar( var_name );
convar_t *var = Cvar_FindVar( var_name );
if( !var ) return 0;
return Q_atoi( var->string );
@@ -873,8 +857,6 @@ Cvar_VariableString
*/
const char *Cvar_VariableString( const char *var_name )
{
convar_t *var;
if( !var_name )
{
// there is an error in C code if this happens
@@ -882,7 +864,7 @@ const char *Cvar_VariableString( const char *var_name )
return "";
}
var = Cvar_FindVar( var_name );
convar_t *var = Cvar_FindVar( var_name );
if( !var ) return "";
return var->string;
@@ -909,10 +891,8 @@ Any testing variables will be reset to the safe values
*/
void Cvar_SetCheatState( void )
{
convar_t *var;
// set all default vars to the safe value
for( var = cvar_vars; var; var = var->next )
for( convar_t *var = cvar_vars; var; var = var->next )
{
// can't process dll cvars - missed def_string
if( !FBitSet( var->flags, FCVAR_ALLOCATED|FCVAR_EXTENDED ))
@@ -959,7 +939,6 @@ static int ShouldSetCvar_splitstr_handler( char *prev, char *next, void *userdat
static qboolean Cvar_ShouldSetCvar( convar_t *v, qboolean isPrivileged )
{
const char *prefixes[] = { "cl_", "gl_", "m_", "r_", "hud_", "joy_", "con_", "scr_" };
int i;
if( isPrivileged )
return true;
@@ -981,7 +960,7 @@ static qboolean Cvar_ShouldSetCvar( convar_t *v, qboolean isPrivileged )
if( FBitSet( v->flags, FCVAR_FILTERABLE ))
return false;
for( i = 0; i < ARRAYSIZE( prefixes ); i++ )
for( int i = 0; i < ARRAYSIZE( prefixes ); i++ )
{
if( !Q_strnicmp( v->name, prefixes[i], Q_strlen( prefixes[i] )))
return false;
@@ -1046,9 +1025,7 @@ with the specified flag set to true.
*/
void Cvar_WriteVariables( file_t *f, int group )
{
convar_t *var;
for( var = cvar_vars; var; var = var->next )
for( convar_t *var = cvar_vars; var; var = var->next )
{
if( FBitSet( var->flags, group ))
FS_Printf( f, "%s \"%s\"\n", var->name, var->string );
@@ -1064,15 +1041,13 @@ Toggles a cvar for easy single key binding
*/
static void Cvar_Toggle_f( void )
{
int v;
if( Cmd_Argc() != 2 )
{
Con_Printf( S_USAGE "toggle <variable>\n" );
return;
}
v = !Cvar_VariableInteger( Cmd_Argv( 1 ));
int v = !Cvar_VariableInteger( Cmd_Argv( 1 ));
Cvar_Set( Cmd_Argv( 1 ), v ? "1" : "0" );
}
@@ -1087,10 +1062,10 @@ weren't declared in C code.
*/
static void Cvar_Set_f( void )
{
int i, c, l = 0, len;
char combined[MAX_CMD_TOKENS];
int l = 0;
c = Cmd_Argc();
int c = Cmd_Argc();
if( c < 3 )
{
Msg( S_USAGE "set <variable> <value>\n" );
@@ -1098,9 +1073,9 @@ static void Cvar_Set_f( void )
}
combined[0] = 0;
for( i = 2; i < c; i++ )
for( int i = 2; i < c; i++ )
{
len = Q_strlen( Cmd_Argv(i) + 1 );
int len = Q_strlen( Cmd_Argv(i) + 1 );
if( l + len >= MAX_CMD_TOKENS - 2 )
break;
Q_strncat( combined, Cmd_Argv( i ), sizeof( combined ));
@@ -1134,7 +1109,6 @@ Cvar_List_f
*/
static void Cvar_List_f( void )
{
convar_t *var;
const char *match = NULL;
int count = 0;
size_t matchlen = 0;
@@ -1145,10 +1119,9 @@ static void Cvar_List_f( void )
matchlen = Q_strlen( match );
}
for( var = cvar_vars; var; var = var->next )
for( convar_t *var = cvar_vars; var; var = var->next )
{
char value[MAX_VA_STRING];
char *p;
if( var->name[0] == '@' )
continue; // never shows system cvars
@@ -1156,7 +1129,7 @@ static void Cvar_List_f( void )
if( match && !Q_strnicmpext( match, var->name, matchlen ))
continue;
p = Q_strchr( var->string, '^' );
char *p = Q_strchr( var->string, '^' );
if( IsColorString( p ))
Q_snprintf( value, sizeof( value ), "\"%s\"", var->string );
@@ -1195,12 +1168,10 @@ unlink all cvars with specified flag
*/
void Cvar_Unlink( uint32_t group )
{
int count;
if( !Cvar_ValidateUnlinkGroup( group ))
return;
count = Cvar_UnlinkVar( NULL, group );
int count = Cvar_UnlinkVar( NULL, group );
Con_Reportf( "unlink %i cvars\n", count );
}
@@ -1208,18 +1179,14 @@ pending_cvar_t *Cvar_PrepareToUnlink( uint32_t group )
{
pending_cvar_t *list = NULL;
pending_cvar_t *tail = NULL;
convar_t *cv;
for( cv = cvar_vars; cv != NULL; cv = cv->next )
for( convar_t *cv = cvar_vars; cv != NULL; cv = cv->next )
{
size_t namelen;
pending_cvar_t *p;
if( !FBitSet( cv->flags, group ))
continue;
namelen = Q_strlen( cv->name ) + 1;
p = Mem_Malloc( cvar_pool, sizeof( *list ) + namelen );
size_t namelen = Q_strlen( cv->name ) + 1;
pending_cvar_t *p = Mem_Malloc( cvar_pool, sizeof( *list ) + namelen );
p->next = NULL;
p->cv_cur = cv;
p->cv_next = cv->next;
@@ -1320,9 +1287,7 @@ Cvar_PostFSInit
*/
void Cvar_PostFSInit( void )
{
int i;
for( i = 0; i < ARRAYSIZE( cvar_filter_quirks ); i++ )
for( int i = 0; i < ARRAYSIZE( cvar_filter_quirks ); i++ )
{
if( !Q_stricmp( cvar_filter_quirks[i].gamedir, GI->gamefolder ))
{

4
engine/common/dedicated.c
View File

@@ -35,9 +35,7 @@ const char *CL_MsgInfo( int cmd )
}
else if( cmd > svc_lastmsg && cmd <= ( svc_lastmsg + MAX_USER_MESSAGES ))
{
int i;
for( i = 0; i < MAX_USER_MESSAGES; i++ )
for( int i = 0; i < MAX_USER_MESSAGES; i++ )
{
if( svgame.msg[i].number == cmd )
{

9
engine/common/filesystem_engine.c
View File

@@ -70,9 +70,7 @@ byte *FS_LoadDirectFile( const char *path, fs_offset_t *filesizeptr )
static void COM_StripDirectorySlash( char *pname )
{
size_t len;
len = Q_strlen( pname );
size_t len = Q_strlen( pname );
if( len > 0 && pname[len - 1] == '/' )
pname[len - 1] = 0;
}
@@ -128,7 +126,6 @@ static void FS_LoadVFSConfig( const char *gamedir )
void FS_SaveVFSConfig( void )
{
file_t *f;
const qboolean force_save = !FS_FileExists( "vfs.cfg", true );
if( !force_save && !FBitSet( fs_mount_hd.flags|fs_mount_lv.flags|fs_mount_l10n.flags|fs_mount_addon.flags|ui_language.flags, FCVAR_CHANGED ))
@@ -139,7 +136,7 @@ void FS_SaveVFSConfig( void )
Con_Printf( "%s()\n", __func__ );
f = FS_Open( "vfs.cfg.new", "w", true );
file_t *f = FS_Open( "vfs.cfg.new", "w", true );
if( !f )
{
Con_Printf( S_ERROR "%s: can't open %s for write\n", __func__, "vfs.cfg.new" );
@@ -219,7 +216,6 @@ static void FS_UnloadProgs( void )
static qboolean FS_LoadProgs( void )
{
const char *name = FILESYSTEM_STDIO_DLL;
FSAPI GetFSAPI;
fs_hInstance = COM_LoadLibrary( name, false, true );
@@ -229,6 +225,7 @@ static qboolean FS_LoadProgs( void )
return false;
}
FSAPI GetFSAPI;
if( !( GetFSAPI = (FSAPI)COM_GetProcAddress( fs_hInstance, GET_FS_API )))
{
FS_UnloadProgs();

46
engine/common/host.c
View File

@@ -121,7 +121,6 @@ static void Host_MakeVersionString( char *out, size_t len )
static void Host_PrintUsage( const char *exename )
{
string version_str;
const char *usage_str;
Host_MakeVersionString( version_str, sizeof( version_str ));
@@ -136,7 +135,7 @@ static void Host_PrintUsage( const char *exename )
#endif
#define O( x, y ) " "x" "y"\n"
usage_str = S_USAGE XASH_EXE " [options] [+command] [+command2 arg] ...\n"
const char *usage_str = S_USAGE XASH_EXE " [options] [+command] [+command2 arg] ...\n"
"\nCommon options:\n"
O("-dev [level] ", "set log verbosity 0-2")
@@ -235,12 +234,11 @@ static void Host_PrintBugcompUsage( const char *exename )
string version_str;
char usage_str[4096];
char *p = usage_str;
int i;
Host_MakeVersionString( version_str, sizeof( version_str ));
p += Q_snprintf( p, sizeof( usage_str ) - ( usage_str - p ), "Known bugcomp flags are:\n" );
for( i = 0; i < ARRAYSIZE( bugcomp_features ); i++ )
for( int i = 0; i < ARRAYSIZE( bugcomp_features ); i++ )
p += Q_snprintf( p, sizeof( usage_str ) - ( usage_str - p ), " %s: %s\n", bugcomp_features[i].arg, bugcomp_features[i].msg );
p += Q_snprintf( p, sizeof( usage_str ) - ( usage_str - p ), "\nIt is possible to combine multiple flags with '+' characters.\nExample: -bugcomp flag1+flag2+flag3...\n" );
@@ -262,9 +260,7 @@ Host_PrintEngineFeatures
*/
static void Host_PrintFeatures( uint32_t flags, const char *s, const feature_message_t *features, size_t size )
{
size_t i;
for( i = 0; i < size; i++ )
for( size_t i = 0; i < size; i++ )
{
if( FBitSet( flags, features[i].mask ))
Con_Printf( "^3%s:^7 %s is enabled\n", s, features[i].msg );
@@ -340,7 +336,6 @@ static int Host_CalcSleep( void )
if( sv_hibernate_when_empty.value )
{
int players, bots;
SV_GetPlayerCount( &players, &bots );
if( sv_hibernate_when_empty_include_bots.value )
@@ -423,14 +418,13 @@ Host_RegisterDecal
*/
static qboolean Host_RegisterDecal( const char *name, int *count )
{
char shortname[MAX_QPATH];
int i;
if( COM_StringEmptyOrNULL( name ))
return 0;
char shortname[MAX_QPATH];
COM_FileBase( name, shortname, sizeof( shortname ));
int i;
for( i = 1; i < MAX_DECALS && host.draw_decals[i][0]; i++ )
{
if( !Q_stricmp( host.draw_decals[i], shortname ))
@@ -457,15 +451,14 @@ Host_InitDecals
*/
static void Host_InitDecals( void )
{
int i, num_decals = 0;
search_t *t;
int num_decals = 0;
memset( host.draw_decals, 0, sizeof( host.draw_decals ));
// lookup all the decals in decals.wad (basedir, gamedir, falldir)
t = FS_Search( "decals.wad/*.*", true, false );
search_t *t = FS_Search( "decals.wad/*.*", true, false );
for( i = 0; t && i < t->numfilenames; i++ )
for( int i = 0; t && i < t->numfilenames; i++ )
{
if( !Host_RegisterDecal( t->filenames[i], &num_decals ))
break;
@@ -484,8 +477,7 @@ Add them exactly as if they had been typed at the console
*/
static void Host_GetCommands( void )
{
char *cmd;
char *cmd;
while( ( cmd = Platform_Input() ) )
{
Cbuf_AddText( cmd );
@@ -541,7 +533,6 @@ static double Host_CalcFPS( void )
static qboolean Host_Autosleep( double dt, double scale )
{
double targetframetime;
int sleep;
double fps = Host_CalcFPS();
if( fps <= 0 )
@@ -555,7 +546,7 @@ static qboolean Host_Autosleep( double dt, double scale )
else
targetframetime = ( 1.0 / fps );
sleep = Host_CalcSleep();
int sleep = Host_CalcSleep();
if( sleep <= 0 ) // no sleeps between frames, much simpler code
{
if( dt < targetframetime * scale )
@@ -627,11 +618,10 @@ Returns false if the time is too short to run a frame
static qboolean Host_FilterTime( double time )
{
static double oldtime;
double dt;
double scale = sys_timescale.value;
host.realtime += time * scale;
dt = host.realtime - oldtime;
double dt = host.realtime - oldtime;
// clamp the fps in multiplayer games
if( !Host_Autosleep( dt, scale ))
@@ -657,13 +647,11 @@ Host_Frame
*/
void Host_Frame( double time )
{
double t1;
// decide the simulation time
if( !Host_FilterTime( time ))
return;
t1 = Platform_DoubleTime();
double t1 = Platform_DoubleTime();
if( host.framecount == 0 )
Con_DPrintf( "Time to first frame: %.3f seconds\n", t1 - host.starttime );
@@ -990,7 +978,7 @@ Host_InitCommon
static void Host_InitCommon( int argc, char **argv, const char *progname, qboolean bChangeGame, char *exename, size_t exename_size )
{
const char *basedir = progname[0] == '#' ? progname + 1 : progname;
int ticrate, developer = DEFAULT_DEV;
int developer = DEFAULT_DEV;
// some commands may turn engine into infinite loop,
// e.g. xash.exe +game xash -game xash
@@ -1069,6 +1057,7 @@ static void Host_InitCommon( int argc, char **argv, const char *progname, qboole
Cvar_DirectSetValue( &host_developer, developer );
Cvar_RegisterVariable( &sys_ticrate );
int ticrate;
if( Sys_GetIntFromCmdLine( "-sys_ticrate", &ticrate ))
Cvar_DirectSetValue( &sys_ticrate, bound( MIN_FPS, ticrate, MAX_FPS_HARD ));
@@ -1092,10 +1081,8 @@ static void Host_InitCommon( int argc, char **argv, const char *progname, qboole
// print current developer level to simplify processing users feedback
if( developer > 0 )
{
int i;
Con_Printf( "Program args: " S_YELLOW );
for( i = 0; i < host.argc; i++ )
for( int i = 0; i < host.argc; i++ )
Con_Printf( "%s ", host.argv[i] );
Con_Printf( S_DEFAULT "\n" );
@@ -1158,7 +1145,7 @@ Host_Main
int EXPORT Host_Main( int argc, char **argv, const char *progname, int bChangeGame, pfnChangeGame pChangeGame )
{
static double oldtime;
string demoname, exename;
string exename;
if( setjmp( return_from_main_buf ))
return error_on_exit;
@@ -1287,6 +1274,7 @@ int EXPORT Host_Main( int argc, char **argv, const char *progname, int bChangeGa
IN_GyroCheckAvailability();
#endif
string demoname;
if( Sys_GetParmFromCmdLine( "-timedemo", demoname ))
Cbuf_AddTextf( "timedemo %s\n", demoname );

5
engine/common/host_state.c
View File

@@ -193,14 +193,13 @@ void Host_AbortCurrentFrame( void )
void COM_Frame( double time )
{
int loopCount = 0;
if( setjmp( g_abortframe ))
return;
int loopCount = 0;
while( 1 )
{
int oldState = GameState->curstate;
int oldState = GameState->curstate;
// execute the current state (and transition to the next state if not in STATE_RUNFRAME)
switch( GameState->curstate )

143
engine/common/hpak.c
View File

@@ -67,9 +67,8 @@ static inline void HPAK_ResourceFromCompat( resource_t *dest, dresource_t *src )
static void HPAK_AddToQueue( const char *name, resource_t *pResource, void *data, file_t *f )
{
hash_pack_queue_t *p;
hash_pack_queue_t *p = Z_Malloc( sizeof( hash_pack_queue_t ));
p = Z_Malloc( sizeof( hash_pack_queue_t ));
p->name = copystring( name );
p->resource = *pResource;
p->size = pResource->nDownloadSize;
@@ -85,9 +84,7 @@ static void HPAK_AddToQueue( const char *name, resource_t *pResource, void *data
void HPAK_FlushHostQueue( void )
{
hash_pack_queue_t *p;
for( p = gp_hpak_queue; p != NULL; p = gp_hpak_queue )
for( hash_pack_queue_t *p = gp_hpak_queue; p != NULL; p = gp_hpak_queue )
{
gp_hpak_queue = p->next;
HPAK_AddLump( false, p->name, &p->resource, p->data, NULL );
@@ -100,10 +97,8 @@ void HPAK_FlushHostQueue( void )
static void HPAK_CreatePak( const char *filename, resource_t *pResource, byte *pData, file_t *fin )
{
int filelocation;
string pakname;
byte md5[16];
file_t *fout;
MD5Context_t ctx = { 0 };
if( COM_StringEmptyOrNULL( filename ))
@@ -117,7 +112,7 @@ static void HPAK_CreatePak( const char *filename, resource_t *pResource, byte *p
Con_Printf( "creating HPAK %s.\n", pakname );
fout = FS_Open( pakname, "wb", true );
file_t *fout = FS_Open( pakname, "wb", true );
if( !fout )
{
Con_DPrintf( S_ERROR "%s: can't write %s.\n", __func__, pakname );
@@ -129,11 +124,9 @@ static void HPAK_CreatePak( const char *filename, resource_t *pResource, byte *p
if( pData == NULL )
{
byte *temp;
int filelocation = FS_Tell( fin );
byte *temp = Z_Malloc( pResource->nDownloadSize );
// there are better ways
filelocation = FS_Tell( fin );
temp = Z_Malloc( pResource->nDownloadSize );
FS_Read( fin, temp, pResource->nDownloadSize );
FS_Seek( fin, filelocation, SEEK_SET );
MD5Update( &ctx, temp, pResource->nDownloadSize );
@@ -173,7 +166,7 @@ static void HPAK_CreatePak( const char *filename, resource_t *pResource, byte *p
FS_Write( fout, pData, hash_pack_info.entries[0].disksize );
}
filelocation = FS_Tell( fout );
int filelocation = FS_Tell( fout );
FS_Write( fout, &hash_pack_info.count, sizeof( hash_pack_info.count ));
FS_Write( fout, &hash_pack_info.entries[0], sizeof( hpak_lump_t ));
@@ -189,9 +182,7 @@ static void HPAK_CreatePak( const char *filename, resource_t *pResource, byte *p
static qboolean HPAK_FindResource( hpak_info_t *hpk, byte *hash, resource_t *pResource )
{
int i;
for( i = 0; i < hpk->count; i++ )
for( int i = 0; i < hpk->count; i++ )
{
if( !memcmp( hpk->entries[i].resource.rgucMD5_hash, hash, 16 ))
{
@@ -206,12 +197,9 @@ static qboolean HPAK_FindResource( hpak_info_t *hpk, byte *hash, resource_t *pRe
void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource, byte *pData, file_t *pFile )
{
int i, j, position, length;
hpak_lump_t *pCurrentEntry = NULL;
string srcname, dstname;
hpak_info_t srcpak, dstpak;
file_t *file_src;
file_t *file_dst;
byte md5[16];
MD5Context_t ctx = { 0 };
@@ -229,11 +217,9 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
if( !pData )
{
byte *temp;
int position = FS_Tell( pFile );
byte *temp = Z_Malloc( pResource->nDownloadSize );
// there are better ways
position = FS_Tell( pFile );
temp = Z_Malloc( pResource->nDownloadSize );
FS_Read( pFile, temp, pResource->nDownloadSize );
FS_Seek( pFile, position, SEEK_SET );
MD5Update( &ctx, temp, pResource->nDownloadSize );
@@ -261,7 +247,7 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
Q_strncpy( srcname, name, sizeof( srcname ));
COM_ReplaceExtension( srcname, ".hpk", sizeof( srcname ));
file_src = FS_Open( srcname, "rb", true );
file_t *file_src = FS_Open( srcname, "rb", true );
if( !file_src )
{
@@ -273,7 +259,7 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
Q_strncpy( dstname, srcname, sizeof( dstname ));
COM_ReplaceExtension( dstname, ".hp2", sizeof( dstname ));
file_dst = FS_Open( dstname, "wb", true );
file_t *file_dst = FS_Open( dstname, "wb", true );
if( !file_dst )
{
@@ -294,7 +280,7 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
return;
}
length = FS_FileLength( file_src );
int length = FS_FileLength( file_src );
FS_Seek( file_src, 0, SEEK_SET ); // rewind to start of file
FS_FileCopy( file_dst, file_src, length );
@@ -329,13 +315,13 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
memcpy( dstpak.entries, srcpak.entries, sizeof( hpak_lump_t ) * srcpak.count );
// check is there are entry with same hash
for( i = 0; i < srcpak.count; i++ )
for( int i = 0; i < srcpak.count; i++ )
{
if( memcmp( md5, srcpak.entries[i].resource.rgucMD5_hash, 16 ) == 0 )
{
pCurrentEntry = &dstpak.entries[i];
for( j = i; j < srcpak.count; j++ )
for( int j = i; j < srcpak.count; j++ )
dstpak.entries[j + 1] = srcpak.entries[j];
}
}
@@ -357,7 +343,7 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
hash_pack_header.infotableofs = FS_Tell( file_dst );
FS_Write( file_dst, &dstpak.count, sizeof( dstpak.count ));
for( i = 0; i < dstpak.count; i++ )
for( int i = 0; i < dstpak.count; i++ )
{
FS_Write( file_dst, &dstpak.entries[i], sizeof( hpak_lump_t ));
}
@@ -380,14 +366,9 @@ void HPAK_AddLump( qboolean bUseQueue, const char *name, resource_t *pResource,
static qboolean HPAK_Validate( const char *filename, qboolean quiet, qboolean delete )
{
file_t *f;
hpak_lump_t *dataDir;
hpak_header_t hdr;
byte *dataPak;
int i, num_lumps;
MD5Context_t MD5_Hash;
string pakname;
dresource_t *pRes;
byte md5[16];
if( quiet ) HPAK_FlushHostQueue();
@@ -399,7 +380,7 @@ static qboolean HPAK_Validate( const char *filename, qboolean quiet, qboolean de
Q_strncpy( pakname, filename, sizeof( pakname ));
COM_ReplaceExtension( pakname, ".hpk", sizeof( pakname ));
f = FS_Open( pakname, "rb", true );
file_t *f = FS_Open( pakname, "rb", true );
if( !f )
{
if( !quiet )
@@ -419,6 +400,8 @@ static qboolean HPAK_Validate( const char *filename, qboolean quiet, qboolean de
}
FS_Seek( f, hdr.infotableofs, SEEK_SET );
int num_lumps;
FS_Read( f, &num_lumps, sizeof( num_lumps ));
if( num_lumps < 1 || num_lumps > HPAK_MAX_ENTRIES )
@@ -431,12 +414,12 @@ static qboolean HPAK_Validate( const char *filename, qboolean quiet, qboolean de
if( !quiet ) Con_Printf( "# of Entries: %i\n", num_lumps );
dataDir = Z_Malloc( sizeof( hpak_lump_t ) * num_lumps );
hpak_lump_t *dataDir = Z_Malloc( sizeof( hpak_lump_t ) * num_lumps );
FS_Read( f, dataDir, sizeof( hpak_lump_t ) * num_lumps );
if( !quiet ) Con_Printf( "# Type Size FileName : MD5 Hash\n" );
for( i = 0; i < num_lumps; i++ )
for( int i = 0; i < num_lumps; i++ )
{
if( dataDir[i].disksize < HPAK_ENTRY_MIN_SIZE || dataDir[i].disksize > HPAK_ENTRY_MAX_SIZE )
{
@@ -448,7 +431,7 @@ static qboolean HPAK_Validate( const char *filename, qboolean quiet, qboolean de
return false;
}
dataPak = Z_Malloc( dataDir[i].disksize );
byte *dataPak = Z_Malloc( dataDir[i].disksize );
FS_Seek( f, dataDir[i].filepos, SEEK_SET );
FS_Read( f, dataPak, dataDir[i].disksize );
@@ -457,7 +440,7 @@ static qboolean HPAK_Validate( const char *filename, qboolean quiet, qboolean de
MD5Update( &MD5_Hash, dataPak, dataDir[i].disksize );
MD5Final( md5, &MD5_Hash );
pRes = &dataDir[i].resource;
dresource_t *pRes = &dataDir[i].resource;
if( !quiet )
{
@@ -508,9 +491,8 @@ void HPAK_CheckIntegrity( const char *filename )
void HPAK_CheckSize( const char *filename )
{
string pakname;
int maxsize;
int maxsize = hpk_maxsize.value;
maxsize = hpk_maxsize.value;
if( maxsize <= 0 ) return;
if( COM_StringEmptyOrNULL( filename ) )
@@ -532,14 +514,11 @@ qboolean HPAK_ResourceForHash( const char *filename, byte *hash, resource_t *pRe
hpak_info_t directory;
hpak_header_t header;
string pakname;
qboolean bFound;
file_t *f;
hash_pack_queue_t *p;
if( COM_StringEmptyOrNULL( filename ))
return false;
for( p = gp_hpak_queue; p != NULL; p = p->next )
for( hash_pack_queue_t *p = gp_hpak_queue; p != NULL; p = p->next )
{
if( !Q_stricmp( p->name, filename ) && !memcmp( p->resource.rgucMD5_hash, hash, 16 ))
{
@@ -552,7 +531,7 @@ qboolean HPAK_ResourceForHash( const char *filename, byte *hash, resource_t *pRe
Q_strncpy( pakname, filename, sizeof( pakname ));
COM_ReplaceExtension( pakname, ".hpk", sizeof( pakname ));
f = FS_Open( pakname, "rb", true );
file_t *f = FS_Open( pakname, "rb", true );
if( !f ) return false;
FS_Read( f, &header, sizeof( header ));
@@ -580,7 +559,7 @@ qboolean HPAK_ResourceForHash( const char *filename, byte *hash, resource_t *pRe
directory.entries = Z_Malloc( sizeof( hpak_lump_t ) * directory.count );
FS_Read( f, directory.entries, sizeof( hpak_lump_t ) * directory.count );
bFound = HPAK_FindResource( &directory, hash, pResource );
qboolean bFound = HPAK_FindResource( &directory, hash, pResource );
Mem_Free( directory.entries );
FS_Close( f );
@@ -592,7 +571,6 @@ static qboolean HPAK_ResourceForIndex( const char *filename, int index, resource
hpak_header_t header;
hpak_info_t directory;
string pakname;
file_t *f;
if( COM_StringEmptyOrNULL( filename ) )
return false;
@@ -600,7 +578,7 @@ static qboolean HPAK_ResourceForIndex( const char *filename, int index, resource
Q_strncpy( pakname, filename, sizeof( pakname ));
COM_ReplaceExtension( pakname, ".hpk", sizeof( pakname ));
f = FS_Open( pakname, "rb", true );
file_t *f = FS_Open( pakname, "rb", true );
if( !f )
{
Con_DPrintf( S_ERROR "couldn't open %s.\n", pakname );
@@ -650,14 +628,9 @@ static qboolean HPAK_ResourceForIndex( const char *filename, int index, resource
qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte **buffer, int *bufsize )
{
byte *tmpbuf;
string pakname;
hpak_header_t header;
hpak_info_t directory;
hpak_lump_t *entry;
hash_pack_queue_t *p;
file_t *f;
int i;
if( COM_StringEmptyOrNULL( filename ))
return false;
@@ -665,13 +638,13 @@ qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte
if( buffer ) *buffer = NULL;
if( bufsize ) *bufsize = 0;
for( p = gp_hpak_queue; p != NULL; p = p->next )
for( hash_pack_queue_t *p = gp_hpak_queue; p != NULL; p = p->next )
{
if( !Q_stricmp( p->name, filename ) && !memcmp( p->resource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
{
if( buffer )
{
tmpbuf = Z_Malloc( p->size );
byte *tmpbuf = Z_Malloc( p->size );
memcpy( tmpbuf, p->data, p->size );
*buffer = tmpbuf;
}
@@ -686,7 +659,7 @@ qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte
Q_strncpy( pakname, filename, sizeof( pakname ));
COM_ReplaceExtension( pakname, ".hpk", sizeof( pakname ));
f = FS_Open( pakname, "rb", true );
file_t *f = FS_Open( pakname, "rb", true );
if( !f ) return false;
FS_Read( f, &header, sizeof( header ));
@@ -718,9 +691,9 @@ qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte
directory.entries = Z_Malloc( sizeof( hpak_lump_t ) * directory.count );
FS_Read( f, directory.entries, sizeof( hpak_lump_t ) * directory.count );
for( i = 0; i < directory.count; i++ )
for( int i = 0; i < directory.count; i++ )
{
entry = &directory.entries[i];
hpak_lump_t *entry = &directory.entries[i];
if( entry->filepos > 0 &&
entry->disksize > 0 &&
@@ -730,7 +703,7 @@ qboolean HPAK_GetDataPointer( const char *filename, resource_t *pResource, byte
if( buffer )
{
tmpbuf = Z_Malloc( entry->disksize );
byte *tmpbuf = Z_Malloc( entry->disksize );
FS_Read( f, tmpbuf, entry->disksize );
*buffer = tmpbuf;
}
@@ -755,11 +728,8 @@ void HPAK_RemoveLump( const char *name, resource_t *pResource )
{
string read_path;
string save_path;
file_t *file_src;
file_t *file_dst;
hpak_info_t hpak_read;
hpak_info_t hpak_save;
int i, j;
if( COM_StringEmptyOrNULL( name ) || !pResource )
return;
@@ -769,7 +739,7 @@ void HPAK_RemoveLump( const char *name, resource_t *pResource )
Q_strncpy( read_path, name, sizeof( read_path ));
COM_ReplaceExtension( read_path, ".hpk", sizeof( read_path ));
file_src = FS_Open( read_path, "rb", true );
file_t *file_src = FS_Open( read_path, "rb", true );
if( !file_src )
{
Con_DPrintf( S_ERROR "%s couldn't open.\n", read_path );
@@ -778,7 +748,7 @@ void HPAK_RemoveLump( const char *name, resource_t *pResource )
Q_strncpy( save_path, read_path, sizeof( save_path ));
COM_ReplaceExtension( save_path, ".hp2", sizeof( save_path ));
file_dst = FS_Open( save_path, "wb", true );
file_t *file_dst = FS_Open( save_path, "wb", true );
if( !file_dst )
{
@@ -845,7 +815,7 @@ void HPAK_RemoveLump( const char *name, resource_t *pResource )
Con_Printf( "Removing %s from HPAK %s.\n", pResource->szFileName, read_path );
// If there's a collision, we've just corrupted this hpak.
for( i = 0, j = 0; i < hpak_read.count; i++ )
for( int i = 0, j = 0; i < hpak_read.count; i++ )
{
if( !memcmp( hpak_read.entries[i].resource.rgucMD5_hash, pResource->rgucMD5_hash, 16 ))
continue;
@@ -860,7 +830,7 @@ void HPAK_RemoveLump( const char *name, resource_t *pResource )
hash_pack_header.infotableofs = FS_Tell( file_dst );
FS_Write( file_dst, &hpak_save.count, sizeof( hpak_save.count ));
for( i = 0; i < hpak_save.count; i++ )
for( int i = 0; i < hpak_save.count; i++ )
FS_Write( file_dst, &hpak_save.entries[i], sizeof( hpak_lump_t ));
FS_Seek( file_dst, 0, SEEK_SET );
@@ -877,15 +847,10 @@ void HPAK_RemoveLump( const char *name, resource_t *pResource )
static void HPAK_List_f( void )
{
int nCurrent;
hpak_header_t header;
hpak_info_t directory;
hpak_lump_t *entry;
string lumpname;
string pakname;
const char *type;
const char *size;
file_t *f;
if( Cmd_Argc() != 2 )
{
@@ -899,7 +864,7 @@ static void HPAK_List_f( void )
COM_ReplaceExtension( pakname, ".hpk", sizeof( pakname ));
Con_Printf( "Contents for %s.\n", pakname );
f = FS_Open( pakname, "rb", true );
file_t *f = FS_Open( pakname, "rb", true );
if( !f )
{
Con_DPrintf( S_ERROR "couldn't open %s.\n", pakname );
@@ -938,12 +903,13 @@ static void HPAK_List_f( void )
directory.entries = Z_Malloc( directory.count * sizeof( hpak_lump_t ));
FS_Read( f, directory.entries, directory.count * sizeof( hpak_lump_t ));
for( nCurrent = 0; nCurrent < directory.count; nCurrent++ )
for( int nCurrent = 0; nCurrent < directory.count; nCurrent++ )
{
entry = &directory.entries[nCurrent];
hpak_lump_t *entry = &directory.entries[nCurrent];
const char *type = COM_ResourceTypeFromIndex( entry->resource.type );
const char *size = Q_memprint( entry->resource.nDownloadSize );
COM_FileBase( entry->resource.szFileName, lumpname, sizeof( lumpname ));
type = COM_ResourceTypeFromIndex( entry->resource.type );
size = Q_memprint( entry->resource.nDownloadSize );
Con_Printf( "%i: %10s %s %s\n : %s\n", nCurrent + 1, type, size, lumpname, MD5_Print( entry->resource.rgucMD5_hash ));
}
@@ -955,19 +921,12 @@ static void HPAK_List_f( void )
static void HPAK_Extract_f( void )
{
int nCurrent;
hpak_header_t header;
hpak_info_t directory;
hpak_lump_t *entry;
string lumpname;
string pakname;
string szFileOut;
int nIndex;
byte *pData;
int nDataSize;
const char *type;
const char *size;
file_t *f;
if( Cmd_Argc() != 3 )
{
@@ -990,7 +949,7 @@ static void HPAK_Extract_f( void )
COM_ReplaceExtension( pakname, ".hpk", sizeof( pakname ));
Con_Printf( "Contents for %s.\n", pakname );
f = FS_Open( pakname, "rb", true );
file_t *f = FS_Open( pakname, "rb", true );
if( !f )
{
Con_DPrintf( S_ERROR "couldn't open %s.\n", pakname );
@@ -1029,16 +988,17 @@ static void HPAK_Extract_f( void )
directory.entries = Z_Malloc( directory.count * sizeof( hpak_lump_t ));
FS_Read( f, directory.entries, directory.count * sizeof( hpak_lump_t ));
for( nCurrent = 0; nCurrent < directory.count; nCurrent++ )
for( int nCurrent = 0; nCurrent < directory.count; nCurrent++ )
{
entry = &directory.entries[nCurrent];
hpak_lump_t *entry = &directory.entries[nCurrent];
if( nIndex != -1 && nIndex != nCurrent )
continue;
const char *type = COM_ResourceTypeFromIndex( entry->resource.type );
const char *size = Q_memprint( entry->resource.nDownloadSize );
COM_FileBase( entry->resource.szFileName, lumpname, sizeof( lumpname ) );
type = COM_ResourceTypeFromIndex( entry->resource.type );
size = Q_memprint( entry->resource.nDownloadSize );
Con_Printf( "Extracting %i: %10s %s %s\n", nCurrent + 1, type, size, lumpname );
@@ -1048,8 +1008,9 @@ static void HPAK_Extract_f( void )
continue;
}
nDataSize = entry->disksize;
pData = Z_Malloc( nDataSize + 1 );
int nDataSize = entry->disksize;
byte *pData = Z_Malloc( nDataSize + 1 );
FS_Seek( f, entry->filepos, SEEK_SET );
FS_Read( f, pData, nDataSize );

75
engine/common/http/net_http_xash.c
View File

@@ -228,14 +228,12 @@ static int HTTP_FileQueue( httpfile_t *file )
static int HTTP_FileResolveNS( httpfile_t *file )
{
net_gai_state_t res;
if( http.resolving )
return 0;
memset( &file->addr, 0, sizeof( file->addr ));
res = NET_StringToSockaddr( file->server->host, &file->addr, true, AF_UNSPEC );
net_gai_state_t res = NET_StringToSockaddr( file->server->host, &file->addr, true, AF_UNSPEC );
switch( file->addr.ss_family )
{
@@ -343,9 +341,7 @@ static int HTTP_FileConnect( httpfile_t *file )
static int HTTP_FileSendRequest( httpfile_t *file )
{
int res = -1;
res = send( file->socket, file->buf + file->bytes_sent, file->query_length - file->bytes_sent, 0 );
int res = send( file->socket, file->buf + file->bytes_sent, file->query_length - file->bytes_sent, 0 );
if( res >= 0 )
{
@@ -382,7 +378,6 @@ static int HTTP_FileSendRequest( httpfile_t *file )
static int HTTP_FileDecompress( httpfile_t *file )
{
fs_offset_t len;
#pragma pack( push, 1 )
struct
{
@@ -406,13 +401,9 @@ static int HTTP_FileDecompress( httpfile_t *file )
z_stream decompress_stream;
char name[MAX_SYSPATH];
fs_offset_t deflate_pos;
size_t compressed_len, decompressed_len;
byte *data_in, *data_out;
int zlib_result;
g_fsapi.Seek( file->file, 0, SEEK_END );
len = g_fsapi.Tell( file->file );
fs_offset_t len = g_fsapi.Tell( file->file );
g_fsapi.Seek( file->file, 0, SEEK_SET );
if( g_fsapi.Read( file->file, &hdr, sizeof( hdr )) != sizeof( hdr ))
@@ -430,10 +421,9 @@ static int HTTP_FileDecompress( httpfile_t *file )
if( FBitSet( hdr.flags, GZFLG_FEXTRA ))
{
byte res[2];
uint16_t xlen;
g_fsapi.Read( file->file, res, sizeof( res ));
xlen = res[0] | res[1] << 16;
uint16_t xlen = res[0] | res[1] << 16;
g_fsapi.Seek( file->file, xlen, SEEK_CUR );
}
@@ -458,8 +448,9 @@ static int HTTP_FileDecompress( httpfile_t *file )
if( FBitSet( hdr.flags, GZFLG_FHCRC ))
g_fsapi.Seek( file->file, 2, SEEK_CUR );
deflate_pos = g_fsapi.Tell( file->file );
compressed_len = len - deflate_pos;
fs_offset_t deflate_pos = g_fsapi.Tell( file->file );
size_t compressed_len = len - deflate_pos;
size_t decompressed_len;
{
byte data[4];
@@ -479,8 +470,8 @@ static int HTTP_FileDecompress( httpfile_t *file )
return 0;
}
data_in = Mem_Malloc( host.mempool, compressed_len + 1 );
data_out = Mem_Malloc( host.mempool, decompressed_len + 1 );
byte *data_in = Mem_Malloc( host.mempool, compressed_len + 1 );
byte *data_out = Mem_Malloc( host.mempool, decompressed_len + 1 );
HTTP_DownloadPath( name, sizeof( name ), file->path, false );
@@ -502,7 +493,7 @@ static int HTTP_FileDecompress( httpfile_t *file )
return 0;
}
zlib_result = inflate( &decompress_stream, Z_NO_FLUSH );
int zlib_result = inflate( &decompress_stream, Z_NO_FLUSH );
inflateEnd( &decompress_stream );
if( zlib_result == Z_OK || zlib_result == Z_STREAM_END )
@@ -550,7 +541,7 @@ remove files with HTTP_FREE state from list
static void HTTP_AutoClean( void )
{
char buf[1024];
httpfile_t *cur, **prev = &http.first_file;
httpfile_t **prev = &http.first_file;
sizebuf_t msg;
MSG_Init( &msg, "DlFile", buf, sizeof( buf ));
@@ -558,7 +549,7 @@ static void HTTP_AutoClean( void )
// clean all files marked to free
while( 1 )
{
cur = *prev;
httpfile_t *cur = *prev;
if( !cur )
break;
@@ -605,7 +596,6 @@ static int HTTP_FileSaveReceivedData( httpfile_t *file, int pos, int length )
while( length > 0 )
{
int oldpos = pos;
int ret;
int len_to_write;
if( file->chunked && file->chunksize <= 0 )
@@ -670,7 +660,7 @@ static int HTTP_FileSaveReceivedData( httpfile_t *file, int pos, int length )
len_to_write = Q_min( length, file->chunksize );
else len_to_write = length;
ret = FS_Write( file->file, &file->buf[pos], len_to_write );
int ret = FS_Write( file->file, &file->buf[pos], len_to_write );
if( ret != len_to_write )
{
// close it and go to next
@@ -724,18 +714,15 @@ static int HTTP_FileProcessStream( httpfile_t *curfile )
if( begin ) // Got full header
{
char *content_length;
char *content_encoding;
char *transfer_encoding;
*begin = 0; // cut string to print out response
if( !Q_strstr( curfile->buf, "200 OK" ))
{
char *p;
int num = -1;
p = Q_strchr( curfile->buf, '\r' );
char *p = Q_strchr( curfile->buf, '\r' );
if( !p ) p = Q_strchr( curfile->buf, '\n' );
if( p ) *p = 0;
@@ -766,7 +753,7 @@ static int HTTP_FileProcessStream( httpfile_t *curfile )
return 0;
}
content_encoding = Q_stristr( curfile->buf, "Content-Encoding" );
char *content_encoding = Q_stristr( curfile->buf, "Content-Encoding" );
if( content_encoding ) // fetch compressed status
{
content_encoding += sizeof( "Content-Encoding: " ) - 1;
@@ -792,10 +779,8 @@ static int HTTP_FileProcessStream( httpfile_t *curfile )
}
else if(( content_length = Q_stristr( curfile->buf, "Content-Length: " ) ))
{
int size;
content_length += sizeof( "Content-Length: " ) - 1;
size = Q_atoi( content_length );
int size = Q_atoi( content_length );
Con_Reportf( "HTTP: Got 200 OK! File size is %d%s\n", curfile->size, curfile->compressed ? ", compressed" : "" );
@@ -912,13 +897,11 @@ Call every frame
*/
void HTTP_Run( void )
{
httpfile_t *curfile;
http.resolving = false;
http.progress_count = 0;
http.progress = 0;
for( curfile = http.first_file; curfile; curfile = curfile->next )
for( httpfile_t *curfile = http.first_file; curfile; curfile = curfile->next )
{
int move_next = 1;
@@ -948,8 +931,6 @@ Add new download to end of queue
*/
void HTTP_AddDownload( const char *path, int size, qboolean process, resource_t *res )
{
httpfile_t *httpfile;
if( COM_CheckNastyPath( path ))
{
Con_Printf( S_ERROR "%s: refused to download %s, nasty path\n", __func__, path );
@@ -962,7 +943,7 @@ void HTTP_AddDownload( const char *path, int size, qboolean process, resource_t
return;
}
httpfile = Z_Calloc( sizeof( *httpfile ));
httpfile_t *httpfile = Z_Calloc( sizeof( *httpfile ));
Con_Reportf( "File %s queued to download\n", path );
@@ -1005,11 +986,7 @@ HTTP_ParseURL
*/
static httpserver_t *HTTP_ParseURL( const char *url_ )
{
httpserver_t *server;
int i;
const char *url = NULL;
url = Q_strstr( url_, "http://" );
const char *url = Q_strstr( url_, "http://" );
if( url )
url += 7;
@@ -1023,8 +1000,8 @@ static httpserver_t *HTTP_ParseURL( const char *url_ )
if( !url )
return NULL;
server = Z_Calloc( sizeof( httpserver_t ));
i = 0;
httpserver_t *server = Z_Calloc( sizeof( httpserver_t ));
int i = 0;
while( *url && ( *url != ':' ) && ( *url != '/' ) && ( *url != '\r' ) && ( *url != '\n' ))
{
@@ -1164,19 +1141,17 @@ Print all pending downloads to console
static void HTTP_List_f( void )
{
int i = 0;
httpfile_t *file;
if( !http.first_file )
Con_Printf( "no downloads queued\n" );
for( file = http.first_file; file; file = file->next )
for( httpfile_t *file = http.first_file; file; file = file->next )
{
Con_Printf( "%d. %s (%d of %d)\n", i++, file->path, file->downloaded, file->size );
if( file->server )
{
httpserver_t *server;
for( server = file->server; server; server = server->next )
for( httpserver_t *server = file->server; server; server = server->next )
{
Con_Printf( "\thttp://%s:%d/%s%s\n", file->server->host, file->server->port,
file->server->path, file->path );
@@ -1194,9 +1169,7 @@ When connected to new server, all old files should not increase counter
*/
void HTTP_ResetProcessState( void )
{
httpfile_t *file;
for( file = http.first_file; file; file = file->next )
for( httpfile_t *file = http.first_file; file; file = file->next )
file->process = false;
}

47
engine/common/imagelib/img_bmp.c
View File

@@ -42,14 +42,13 @@ Image_LoadBMP
*/
qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesize )
{
byte *buf_p, *pixbuf;
byte *pixbuf;
rgba_t palette[256] = { 0 };
int i, columns, column, rows, row, bpp = 1;
int cbPalBytes = 0, padSize = 0, bps = 0;
int columns, column, rows, row, bpp = 1;
int cbPalBytes = 0, padSize = 0;
uint reflectivity[3] = { 0, 0, 0 };
qboolean load_qfont = false;
bmp_t bhdr;
fs_offset_t estimatedSize;
if( filesize < sizeof( bhdr ))
{
@@ -57,7 +56,7 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
return false;
}
buf_p = (byte *)buffer;
byte *buf_p = (byte *)buffer;
memcpy( &bhdr, buf_p, sizeof( bmp_t ));
le_struct_swap( bmp_swap, &bhdr );
buf_p += BI_FILE_HEADER_SIZE + bhdr.bitmapHeaderSize;
@@ -132,7 +131,7 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
}
}
estimatedSize = ( buf_p - buffer ) + cbPalBytes;
fs_offset_t estimatedSize = ( buf_p - buffer ) + cbPalBytes;
if( filesize < estimatedSize )
{
Con_Reportf( S_ERROR "%s: %s have incorrect file size %li should be greater than %li (palette)\n", __func__, name, (long)filesize, (long)estimatedSize );
@@ -144,7 +143,7 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
// setup gradient alpha for player decal
if( !Q_strncmp( name, "#logo", 5 ))
{
for( i = 0; i < bhdr.colors; i++ )
for( int i = 0; i < bhdr.colors; i++ )
palette[i][3] = i;
image.flags |= IMAGE_HAS_ALPHA;
}
@@ -152,7 +151,7 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
if( Image_CheckFlag( IL_OVERVIEW ) && bhdr.bitsPerPixel == 8 )
{
// convert green background into alpha-layer, make opacity for all other entries
for( i = 0; i < bhdr.colors; i++ )
for( int i = 0; i < bhdr.colors; i++ )
{
if( palette[i][0] == 0 && palette[i][1] == 255 && palette[i][2] == 0 )
{
@@ -168,7 +167,7 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
pixbuf = image.palette = Mem_Malloc( host.imagepool, 1024 );
// bmp have a reversed palette colors
for( i = 0; i < bhdr.colors; i++ )
for( int i = 0; i < bhdr.colors; i++ )
{
*pixbuf++ = palette[i][2];
*pixbuf++ = palette[i][1];
@@ -185,7 +184,7 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
}
buf_p += cbPalBytes;
bps = image.width * (bhdr.bitsPerPixel >> 3);
int bps = image.width * (bhdr.bitsPerPixel >> 3);
switch( bhdr.bitsPerPixel )
{
@@ -353,14 +352,9 @@ qboolean Image_LoadBMP( const char *name, const byte *buffer, fs_offset_t filesi
qboolean Image_SaveBMP( const char *name, rgbdata_t *pix )
{
file_t *pfile = NULL;
rgba_t rgrgbPalette[256];
dword cbBmpBits;
byte *pb, *pbBmpBits;
dword cbPalBytes;
dword biTrueWidth;
byte *pb;
int pixel_size;
int i, x, y;
bmp_t hdr;
if( FS_FileExists( name, false ) && !Image_CheckFlag( IL_ALLOW_OVERWRITE ) )
@@ -389,14 +383,15 @@ qboolean Image_SaveBMP( const char *name, rgbdata_t *pix )
return false;
}
pfile = FS_Open( name, "wb", false );
if( !pfile ) return false;
file_t *pfile = FS_Open( name, "wb", false );
if( !pfile )
return false;
// NOTE: align transparency column will sucessfully removed
// after create sprite or lump image, it's just standard requiriments
biTrueWidth = ((pix->width + 3) & ~3);
cbBmpBits = biTrueWidth * pix->height * pixel_size;
cbPalBytes = ( pixel_size == 1 ) ? 256 * sizeof( rgba_t ) : 0;
dword biTrueWidth = ((pix->width + 3) & ~3);
dword cbBmpBits = biTrueWidth * pix->height * pixel_size;
dword cbPalBytes = ( pixel_size == 1 ) ? 256 * sizeof( rgba_t ) : 0;
// Bogus file header check
hdr.id[0] = 'B';
@@ -420,14 +415,14 @@ qboolean Image_SaveBMP( const char *name, rgbdata_t *pix )
FS_Write( pfile, &hdr, sizeof( bmp_t ));
le_struct_swap( bmp_swap, &hdr );
pbBmpBits = Mem_Malloc( host.imagepool, cbBmpBits );
byte *pbBmpBits = Mem_Malloc( host.imagepool, cbBmpBits );
if( pixel_size == 1 )
{
pb = pix->palette;
// copy over used entries
for( i = 0; i < (int)hdr.colors; i++ )
for( int i = 0; i < (int)hdr.colors; i++ )
{
rgrgbPalette[i][2] = *pb++;
rgrgbPalette[i][1] = *pb++;
@@ -447,9 +442,9 @@ qboolean Image_SaveBMP( const char *name, rgbdata_t *pix )
pb = pix->buffer;
for( y = 0; y < hdr.height; y++ )
for( int y = 0; y < hdr.height; y++ )
{
i = (hdr.height - 1 - y ) * (hdr.width);
int i = (hdr.height - 1 - y ) * (hdr.width);
if( pixel_size == 1 )
{
@@ -457,7 +452,7 @@ qboolean Image_SaveBMP( const char *name, rgbdata_t *pix )
}
else
{
for( x = 0; x < pix->width; x++ )
for( int x = 0; x < pix->width; x++ )
{
// 24 bit
qboolean be = ImageBigEndian( pix->type );

47
engine/common/imagelib/img_dds.c
View File

@@ -62,22 +62,18 @@ le_struct_end();
static qboolean Image_CheckDXT3Alpha( dds_t *hdr, byte *fin )
{
word sAlpha;
byte *alpha;
int x, y, i, j;
for( y = 0; y < hdr->dwHeight; y += 4 )
for( int y = 0; y < hdr->dwHeight; y += 4 )
{
for( x = 0; x < hdr->dwWidth; x += 4 )
for( int x = 0; x < hdr->dwWidth; x += 4 )
{
alpha = fin + 8;
byte *alpha = fin + 8;
fin += 16;
for( j = 0; j < 4; j++ )
for( int j = 0; j < 4; j++ )
{
sAlpha = alpha[2*j] + 256 * alpha[2*j+1];
word sAlpha = alpha[2*j] + 256 * alpha[2*j+1];
for( i = 0; i < 4; i++ )
for( int i = 0; i < 4; i++ )
{
if((( x + i ) < hdr->dwWidth ) && (( y + j ) < hdr->dwHeight ))
{
@@ -95,27 +91,23 @@ static qboolean Image_CheckDXT3Alpha( dds_t *hdr, byte *fin )
static qboolean Image_CheckDXT5Alpha( dds_t *hdr, byte *fin )
{
uint bits;
byte *alphamask;
int x, y, i, j;
for( y = 0; y < hdr->dwHeight; y += 4 )
for( int y = 0; y < hdr->dwHeight; y += 4 )
{
for( x = 0; x < hdr->dwWidth; x += 4 )
for( int x = 0; x < hdr->dwWidth; x += 4 )
{
if( y >= hdr->dwHeight || x >= hdr->dwWidth )
break;
alphamask = fin + 2;
byte *alphamask = fin + 2;
fin += 8;
fin += 8;
// last three bytes
bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16);
uint bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16);
for( j = 2; j < 4; j++ )
for( int j = 2; j < 4; j++ )
{
for( i = 0; i < 4; i++ )
for( int i = 0; i < 4; i++ )
{
// only put pixels out < width or height
if((( x + i ) < hdr->dwWidth ) && (( y + j ) < hdr->dwHeight ))
@@ -259,14 +251,13 @@ static void Image_DXTGetPixelFormat( dds_t *hdr, dds_header_dxt10_t *headerExt )
static size_t Image_DXTCalcMipmapSize( dds_t *hdr )
{
size_t buffsize = 0;
int i, width, height, depth;
// now correct buffer size
for( i = 0; i < Q_max( 1, ( hdr->dwMipMapCount )); i++ )
for( int i = 0; i < Q_max( 1, ( hdr->dwMipMapCount )); i++ )
{
width = Q_max( 1, ( hdr->dwWidth >> i ));
height = Q_max( 1, ( hdr->dwHeight >> i ));
depth = Q_max( 1, ( image.depth >> i ));
int width = Q_max( 1, ( hdr->dwWidth >> i ));
int height = Q_max( 1, ( hdr->dwHeight >> i ));
int depth = Q_max( 1, ( image.depth >> i ));
buffsize += Image_ComputeSize( image.type, width, height, depth );
}
@@ -325,8 +316,6 @@ Image_LoadDDS
qboolean Image_LoadDDS( const char *name, const byte *buffer, fs_offset_t filesize )
{
dds_t header;
byte *fin;
int headersOffset;
dds_header_dxt10_t header2;
if( filesize < sizeof( header ))
@@ -350,7 +339,7 @@ qboolean Image_LoadDDS( const char *name, const byte *buffer, fs_offset_t filesi
return false;
}
headersOffset = sizeof( header );
int headersOffset = sizeof( header );
if( header.dsPixelFormat.dwFourCC == TYPE_DX10 )
{
memcpy( &header2, buffer + sizeof( header ), sizeof( header2 ));
@@ -381,7 +370,7 @@ qboolean Image_LoadDDS( const char *name, const byte *buffer, fs_offset_t filesi
image.size = Image_DXTCalcSize( name, &header, filesize - headersOffset );
if( image.size == 0 ) return false; // just in case
fin = (byte *)( buffer + headersOffset );
byte *fin = (byte *)( buffer + headersOffset );
// copy an encode method
image.encode = (word)header.dwReserved1[0];

5
engine/common/imagelib/img_ktx2.c
View File

@@ -98,7 +98,6 @@ static qboolean Image_KTX2Parse( const ktx2_header_t *header, const byte *buffer
ktx2_index_t index;
size_t total_size = 0;
size_t max_offset = 0;
int mip, cursor;
const byte *const levels_begin = buffer + KTX2_LEVELS_OFFSET;
// Sets image.type and image.flags
@@ -155,7 +154,7 @@ static qboolean Image_KTX2Parse( const ktx2_header_t *header, const byte *buffer
memcpy( &index, buffer + KTX2_IDENTIFIER_SIZE + sizeof( ktx2_header_t ), sizeof( index ));
le_struct_swap( ktx2_index_swap, &index );
for( mip = 0; mip < header->levelCount; ++mip )
for( int mip = 0; mip < header->levelCount; ++mip )
{
const uint32_t width = Q_max( 1, ( header->pixelWidth >> mip ));
const uint32_t height = Q_max( 1, ( header->pixelHeight >> mip ));
@@ -185,7 +184,7 @@ static qboolean Image_KTX2Parse( const ktx2_header_t *header, const byte *buffer
image.rgba = Mem_Malloc( host.imagepool, image.size );
memcpy( image.rgba, buffer, image.size );
for( mip = 0, cursor = 0; mip < header->levelCount; ++mip )
for( int mip = 0, cursor = 0; mip < header->levelCount; ++mip )
{
ktx2_level_t level;
memcpy( &level, levels_begin + mip * sizeof( level ), sizeof( level ));

64
engine/common/imagelib/img_main.c
View File

@@ -169,8 +169,6 @@ void Image_Reset( void )
static MALLOC_LIKE( FS_FreeImage, 1 ) rgbdata_t *ImagePack( const char *name )
{
rgbdata_t *pack;
Image_ReportLookupsCount( name );
if( Image_CheckFlag( IL_LOAD_PLAYER_DECAL ))
@@ -185,7 +183,7 @@ static MALLOC_LIKE( FS_FreeImage, 1 ) rgbdata_t *ImagePack( const char *name )
return NULL;
}
pack = Mem_Calloc( host.imagepool, sizeof( *pack ));
rgbdata_t *pack = Mem_Calloc( host.imagepool, sizeof( *pack ));
if( image.cubemap )
{
@@ -228,7 +226,6 @@ FS_AddSideToPack
*/
static qboolean FS_AddSideToPack( int adjust_flags )
{
byte *out, *flipped;
qboolean resampled = false;
// first side set average size for all cubemap sides!
@@ -247,12 +244,12 @@ static qboolean FS_AddSideToPack( int adjust_flags )
return false;
// flip image if needed
flipped = Image_FlipInternal( image.rgba, &image.width, &image.height, image.source_type, adjust_flags );
byte *flipped = Image_FlipInternal( image.rgba, &image.width, &image.height, image.source_type, adjust_flags );
if( !flipped ) return false; // try to reasmple dxt?
if( flipped != image.rgba ) image.rgba = Image_Copy( image.size );
// resampling image if needed
out = Image_ResampleInternal((uint *)image.rgba, image.width, image.height, image.source_width, image.source_height, image.source_type, &resampled );
byte *out = Image_ResampleInternal((uint *)image.rgba, image.width, image.height, image.source_width, image.source_height, image.source_type, &resampled );
if( !out ) return false; // try to reasmple dxt?
if( resampled ) image.rgba = Image_Copy( image.size );
@@ -268,12 +265,10 @@ static qboolean FS_AddSideToPack( int adjust_flags )
static const loadpixformat_t *Image_GetLoadFormatForExtension( const char *ext )
{
const loadpixformat_t *format;
if( COM_StringEmpty( ext ))
return NULL;
for( format = image.loadformats; format->ext; format++ )
for( const loadpixformat_t *format = image.loadformats; format->ext; format++ )
{
if( !Q_stricmp( ext, format->ext ))
return format;
@@ -316,10 +311,9 @@ static qboolean Image_ProbeLoad_( const loadpixformat_t *fmt, const char *name,
qboolean success = false;
fs_offset_t filesize;
string path;
byte *f;
Q_snprintf( path, sizeof( path ), "%s%s.%s", name, suffix, fmt->ext );
f = FS_LoadFile( path, &filesize, false );
byte *f = FS_LoadFile( path, &filesize, false );
Image_IncrementLookupTime();
@@ -335,24 +329,21 @@ static qboolean Image_ProbeLoad_( const loadpixformat_t *fmt, const char *name,
static qboolean Image_ProbeLoad2( const char *name, const char *suffix, int override_hint )
{
const loadpixformat_t *fmt;
search_t *t;
string pattern;
int i;
Q_snprintf( pattern, sizeof( pattern ), "%s%s.*", name, suffix );
t = FS_Search( pattern, true, false );
search_t *t = FS_Search( pattern, true, false );
if( !t )
return false;
// we now have to check every extension
// to keep the loading order
for( fmt = image.loadformats; fmt->ext; fmt++ )
for( const loadpixformat_t *fmt = image.loadformats; fmt->ext; fmt++ )
{
fs_offset_t filesize;
byte *data;
int i;
for( i = 0; i < t->numfilenames; i++ )
{
@@ -366,7 +357,7 @@ static qboolean Image_ProbeLoad2( const char *name, const char *suffix, int over
if( i == t->numfilenames )
continue;
data = FS_LoadFile( t->filenames[i], &filesize, false );
byte *data = FS_LoadFile( t->filenames[i], &filesize, false );
Image_IncrementLookupTime();
// can't load file, ignore
@@ -417,14 +408,13 @@ rgbdata_t *FS_LoadImage( const char *filename, const byte *buffer, size_t size )
{
const char *ext = COM_FileExtension( filename );
string loadname;
int i, j;
const loadpixformat_t *extfmt;
Q_strncpy( loadname, filename, sizeof( loadname ));
// we needs to compare file extension with list of supported formats
// and be sure what is real extension, not a filename with dot
if(( extfmt = Image_GetLoadFormatForExtension( ext )))
const loadpixformat_t *extfmt = Image_GetLoadFormatForExtension( ext );
if( extfmt )
COM_StripExtension( loadname );
Image_Reset(); // clear old image
@@ -437,11 +427,11 @@ rgbdata_t *FS_LoadImage( const char *filename, const byte *buffer, size_t size )
return ImagePack( filename );
// check all cubemap sides with package suffix
for( j = 0; j < ARRAYSIZE( load_cubemap ); j++ )
for( int j = 0; j < ARRAYSIZE( load_cubemap ); j++ )
{
const cubepack_t *cmap = &load_cubemap[j];
for( i = 0; i < 6; i++ )
for( int i = 0; i < 6; i++ )
{
if( Image_ProbeLoad( extfmt, loadname, cmap->type[i].suf, cmap->type[i].hint ))
{
@@ -507,7 +497,6 @@ qboolean FS_SaveImage( const char *filename, rgbdata_t *pix )
const char *ext = COM_FileExtension( filename );
qboolean anyformat = COM_StringEmpty( ext );
string path, savename;
const savepixformat_t *format;
if( !pix || !pix->buffer || anyformat )
{
@@ -522,7 +511,6 @@ qboolean FS_SaveImage( const char *filename, rgbdata_t *pix )
if( pix->flags & (IMAGE_CUBEMAP|IMAGE_SKYBOX))
{
size_t realSize = pix->size; // keep real pic size
byte *picBuffer; // to avoid corrupt memory on free data
const suffix_t *box;
int i;
@@ -538,10 +526,10 @@ qboolean FS_SaveImage( const char *filename, rgbdata_t *pix )
}
pix->size /= 6; // now set as side size
picBuffer = pix->buffer;
byte *picBuffer = pix->buffer;
// save all sides seperately
for( format = image.saveformats; format && format->ext; format++ )
for( const savepixformat_t *format = image.saveformats; format && format->ext; format++ )
{
if( !Q_stricmp( ext, format->ext ))
{
@@ -565,7 +553,7 @@ qboolean FS_SaveImage( const char *filename, rgbdata_t *pix )
}
else
{
for( format = image.saveformats; format && format->ext; format++ )
for( const savepixformat_t *format = image.saveformats; format && format->ext; format++ )
{
if( !Q_stricmp( ext, format->ext ))
{
@@ -610,13 +598,12 @@ make an image copy
*/
rgbdata_t *FS_CopyImage( const rgbdata_t *in )
{
rgbdata_t *out;
int palSize = 0;
if( !in )
return NULL;
out = Mem_Malloc( host.imagepool, sizeof( *out ));
rgbdata_t *out = Mem_Malloc( host.imagepool, sizeof( *out ));
*out = *in;
switch( in->type )
@@ -660,10 +647,8 @@ static void GeneratePixel( byte *pix, uint i, uint j, uint w, uint h, qboolean g
static void Test_CheckImage( const char *name, rgbdata_t *rgb )
{
rgbdata_t *load;
// test reading
load = FS_LoadImage( name, NULL, 0 );
rgbdata_t *load = FS_LoadImage( name, NULL, 0 );
TASSERT( load->width == rgb->width )
TASSERT( load->height == rgb->height )
TASSERT( load->type == rgb->type )
@@ -677,9 +662,7 @@ static void Test_CheckImage( const char *name, rgbdata_t *rgb )
void Test_RunImagelib( void )
{
rgbdata_t rgb = { 0 };
byte *buf;
const char *extensions[] = { "tga", "png", "bmp" };
uint i, j;
Image_Setup();
@@ -689,26 +672,25 @@ void Test_RunImagelib( void )
rgb.type = PF_RGBA_32;
rgb.flags = IMAGE_HAS_ALPHA;
rgb.size = rgb.width * rgb.height * 4;
buf = rgb.buffer = Z_Malloc( rgb.size );
byte *buf = rgb.buffer = Z_Malloc( rgb.size );
for( i = 0; i < rgb.height; i++ )
for( uint i = 0; i < rgb.height; i++ )
{
for( j = 0; j < rgb.width; j++ )
for( uint j = 0; j < rgb.width; j++ )
{
GeneratePixel( buf, i, j, rgb.width, rgb.height, true );
buf += 4;
}
}
for( i = 0; i < sizeof(extensions) / sizeof(extensions[0]); i++ )
for( uint i = 0; i < sizeof(extensions) / sizeof(extensions[0]); i++ )
{
qboolean ret;
char name[MAX_VA_STRING];
Q_snprintf( name, sizeof( name ), "test_gen.%s", extensions[i] );
// test saving
ret = FS_SaveImage( name, &rgb );
qboolean ret = FS_SaveImage( name, &rgb );
Con_Printf( "Checking if we can save images in '%s' format...\n", extensions[i] );
ASSERT(ret == true);

46
engine/common/imagelib/img_png.c
View File

@@ -33,12 +33,11 @@ Image_LoadPNG
*/
qboolean Image_LoadPNG( const char *name, const byte *buffer, fs_offset_t filesize )
{
int ret;
short p, a, b, c, pa, pb, pc;
byte *buf_p, *pixbuf, *raw, *prior, *idat_buf = NULL, *uncompressed_buffer = NULL;
byte *pixbuf, *raw, *prior, *idat_buf = NULL, *uncompressed_buffer = NULL;
byte *pallete = NULL, *trns = NULL;
uint chunk_len, trns_len = 0, plte_len = 0, crc32, crc32_check, oldsize = 0, newsize = 0, rowsize;
uint uncompressed_size, pixel_size, pixel_count, i, y, filter_type, chunk_sign, r_alpha, g_alpha, b_alpha;
uint chunk_len, trns_len = 0, plte_len = 0, crc32, crc32_check, oldsize = 0, newsize = 0;
uint pixel_size, i, y, filter_type, chunk_sign, r_alpha, g_alpha, b_alpha;
qboolean has_iend_chunk = false;
z_stream stream = {0};
png_t png_hdr;
@@ -46,7 +45,7 @@ qboolean Image_LoadPNG( const char *name, const byte *buffer, fs_offset_t filesi
if( filesize < sizeof( png_hdr ))
return false;
buf_p = (byte *)buffer;
byte *buf_p = (byte *)buffer;
// get png header
memcpy( &png_hdr, buffer, sizeof( png_t ));
@@ -265,7 +264,7 @@ qboolean Image_LoadPNG( const char *name, const byte *buffer, fs_offset_t filesi
}
image.type = PF_RGBA_32; // always exctracted to 32-bit buffer
pixel_count = image.height * image.width;
uint pixel_count = image.height * image.width;
image.size = pixel_count * 4;
if( png_hdr.ihdr_chunk.colortype & PNG_CT_RGB )
@@ -276,9 +275,9 @@ qboolean Image_LoadPNG( const char *name, const byte *buffer, fs_offset_t filesi
image.depth = 1;
rowsize = pixel_size * image.width;
uint rowsize = pixel_size * image.width;
uncompressed_size = image.height * ( rowsize + 1 ); // +1 for filter
uint uncompressed_size = image.height * ( rowsize + 1 ); // +1 for filter
uncompressed_buffer = Mem_Malloc( host.imagepool, uncompressed_size );
stream.next_in = idat_buf;
@@ -295,7 +294,7 @@ qboolean Image_LoadPNG( const char *name, const byte *buffer, fs_offset_t filesi
return false;
}
ret = inflate( &stream, Z_NO_FLUSH );
int ret = inflate( &stream, Z_NO_FLUSH );
inflateEnd( &stream );
Mem_Free( idat_buf );
@@ -506,10 +505,9 @@ Image_SavePNG
*/
qboolean Image_SavePNG( const char *name, rgbdata_t *pix )
{
int ret;
uint y, outsize, pixel_size, filtered_size, idat_len;
uint ihdr_len, crc32, rowsize, big_idat_len;
byte *in, *buffer, *out, *filtered_buffer, *rowend;
uint pixel_size;
uint crc32;
byte *out;
z_stream stream = {0};
png_t png_hdr;
png_footer_t png_ftr;
@@ -537,19 +535,20 @@ qboolean Image_SavePNG( const char *name, rgbdata_t *pix )
return false;
}
rowsize = pix->width * pixel_size;
uint rowsize = pix->width * pixel_size;
// get filtered image size
filtered_size = ( rowsize + 1 ) * pix->height;
uint filtered_size = ( rowsize + 1 ) * pix->height;
byte *filtered_buffer;
out = filtered_buffer = Mem_Malloc( host.imagepool, filtered_size );
// apply adaptive filter to image
for( y = 0; y < pix->height; y++ )
for( uint y = 0; y < pix->height; y++ )
{
in = pix->buffer + y * pix->width * pixel_size;
byte *in = pix->buffer + y * pix->width * pixel_size;
*out++ = PNG_F_NONE;
rowend = in + rowsize;
byte *rowend = in + rowsize;
for( ; in < rowend; in += pixel_size )
{
*out++ = be ? in[2] : in[0];
@@ -562,13 +561,13 @@ qboolean Image_SavePNG( const char *name, rgbdata_t *pix )
}
// get IHDR chunk length
ihdr_len = sizeof( png_ihdr_t );
uint ihdr_len = sizeof( png_ihdr_t );
// predict IDAT chunk length
idat_len = deflateBound( NULL, filtered_size );
uint idat_len = deflateBound( NULL, filtered_size );
// calculate PNG filesize
outsize = sizeof( png_t );
uint outsize = sizeof( png_t );
outsize += sizeof( idat_len );
outsize += sizeof( idat_sign );
outsize += idat_len;
@@ -612,6 +611,7 @@ qboolean Image_SavePNG( const char *name, rgbdata_t *pix )
// write IHDR chunk CRC
png_hdr.ihdr_crc32 = BigLong( crc32 );
byte *buffer;
out = buffer = (byte *)Mem_Malloc( host.imagepool, outsize );
stream.next_in = filtered_buffer;
@@ -628,7 +628,7 @@ qboolean Image_SavePNG( const char *name, rgbdata_t *pix )
return false;
}
ret = deflate( &stream, Z_FINISH );
int ret = deflate( &stream, Z_FINISH );
deflateEnd( &stream );
Mem_Free( filtered_buffer );
@@ -650,7 +650,7 @@ qboolean Image_SavePNG( const char *name, rgbdata_t *pix )
out += sizeof( png_t );
// convert IDAT chunk length to big endian
big_idat_len = BigLong( idat_len );
uint big_idat_len = BigLong( idat_len );
// write IDAT chunk length
memcpy( out, &big_idat_len, sizeof( idat_len ));

130
engine/common/imagelib/img_quant.c
View File

@@ -68,15 +68,13 @@ static int radpower[initrad]; // radpower for precomputation
static void initnet( byte *thepic, int len, int sample )
{
register int i, *p;
thepicture = thepic;
lengthcount = len;
samplefac = sample;
for( i = 0; i < netsize; i++ )
for( register int i = 0; i < netsize; i++ )
{
p = network[i];
register int *p = network[i];
p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
freq[i] = intbias / netsize; // 1 / netsize
bias[i] = 0;
@@ -86,15 +84,13 @@ static void initnet( byte *thepic, int len, int sample )
// Unbias network to give byte values 0..255 and record position i to prepare for sort
static void unbiasnet( void )
{
int i, j, temp;
for( i = 0; i < netsize; i++ )
for( int i = 0; i < netsize; i++ )
{
for( j = 0; j < 3; j++ )
for( int j = 0; j < 3; j++ )
{
// OLD CODE: network[i][j] >>= netbiasshift;
// Fix based on bug report by Juergen Weigert jw@suse.de
temp = (network[i][j] + (1 << (netbiasshift - 1))) >> netbiasshift;
int temp = (network[i][j] + (1 << (netbiasshift - 1))) >> netbiasshift;
if( temp > 255 ) temp = 255;
network[i][j] = temp;
}
@@ -106,21 +102,18 @@ static void unbiasnet( void )
// Insertion sort of network and building of netindex[0..255] (to do after unbias)
static void inxbuild( void )
{
register int *p, *q;
register int i, j, smallpos, smallval;
int previouscol, startpos;
int previouscol = 0;
int startpos = 0;
previouscol = 0;
startpos = 0;
for( i = 0; i < netsize; i++ )
for( register int i = 0; i < netsize; i++ )
{
p = network[i];
smallpos = i;
smallval = p[1]; // index on g
register int *p = network[i];
register int smallpos = i;
register int smallval = p[1]; // index on g
// find smallest in i..netsize-1
for( j = i + 1; j < netsize; j++ )
register int *q;
for( register int j = i + 1; j < netsize; j++ )
{
q = network[j];
if( q[1] < smallval )
@@ -136,6 +129,7 @@ static void inxbuild( void )
// swap p (i) and q (smallpos) entries
if( i != smallpos )
{
register int j;
j = q[0]; q[0] = p[0]; p[0] = j;
j = q[1]; q[1] = p[1]; p[1] = j;
j = q[2]; q[2] = p[2]; p[2] = j;
@@ -147,7 +141,7 @@ static void inxbuild( void )
{
netindex[previouscol] = (startpos+i) >> 1;
for( j = previouscol + 1; j < smallval; j++ )
for( register int j = previouscol + 1; j < smallval; j++ )
netindex[j] = i;
previouscol = smallval;
@@ -157,7 +151,7 @@ static void inxbuild( void )
netindex[previouscol] = (startpos + maxnetpos)>>1;
for( j = previouscol + 1; j < 256; j++ )
for( int j = previouscol + 1; j < 256; j++ )
netindex[j] = maxnetpos; // really 256
}
@@ -165,14 +159,13 @@ static void inxbuild( void )
// Search for BGR values 0..255 (after net is unbiased) and return colour index
static int inxsearch( int r, int g, int b )
{
register int i, j, dist, a, bestd;
register int dist, a;
register int *p;
int best;
bestd = 1000; // biggest possible dist is 256 * 3
best = -1;
i = netindex[g]; // index on g
j = i - 1; // start at netindex[g] and work outwards
register int bestd = 1000; // biggest possible dist is 256 * 3
int best = -1;
register int i = netindex[g]; // index on g
register int j = i - 1; // start at netindex[g] and work outwards
while(( i < netsize ) || ( j >= 0 ))
{
@@ -246,25 +239,22 @@ static int inxsearch( int r, int g, int b )
// Search for biased BGR values
static int contest( int r, int g, int b )
{
register int *p, *f, *n;
register int i, dist, a, biasdist, betafreq;
int bestpos, bestbiaspos, bestd, bestbiasd;
// finds closest neuron (min dist) and updates freq
// finds best neuron (min dist-bias) and returns position
// for frequently chosen neurons, freq[i] is high and bias[i] is negative
// bias[i] = gamma * ((1 / netsize) - freq[i])
bestd = INT_MAX;
bestbiasd = bestd;
bestpos = -1;
bestbiaspos = bestpos;
p = bias;
f = freq;
int bestd = INT_MAX;
int bestbiasd = bestd;
int bestpos = -1;
int bestbiaspos = bestpos;
register int *p = bias;
register int *f = freq;
for( i = 0; i < netsize; i++ )
for( register int i = 0; i < netsize; i++ )
{
n = network[i];
dist = n[2] - b;
register int *n = network[i];
register int dist = n[2] - b;
register int a;
if( dist < 0 ) dist = -dist;
a = n[1] - g;
if( a < 0 ) a = -a;
@@ -279,7 +269,7 @@ static int contest( int r, int g, int b )
bestpos = i;
}
biasdist = dist - ((*p) >> (intbiasshift - netbiasshift));
register int biasdist = dist - ((*p) >> (intbiasshift - netbiasshift));
if( biasdist < bestbiasd )
{
@@ -287,7 +277,7 @@ static int contest( int r, int g, int b )
bestbiaspos = i;
}
betafreq = (*f >> betashift);
register int betafreq = (*f >> betashift);
*f++ -= betafreq;
*p++ += (betafreq << gammashift);
}
@@ -301,9 +291,7 @@ static int contest( int r, int g, int b )
// Move neuron i towards biased (b,g,r) by factor alpha
static void altersingle( int alpha, int i, int r, int g, int b )
{
register int *n;
n = network[i]; // alter hit neuron
register int *n = network[i]; // alter hit neuron
*n -= (alpha * (*n - r)) / initalpha;
n++;
*n -= (alpha * (*n - g)) / initalpha;
@@ -314,21 +302,19 @@ static void altersingle( int alpha, int i, int r, int g, int b )
// Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
static void alterneigh( int rad, int i, int r, int g, int b )
{
register int j, k, lo, hi, a;
register int *p, *q;
lo = i - rad;
register int lo = i - rad;
if( lo < -1 ) lo = -1;
hi = i + rad;
register int hi = i + rad;
if( hi > netsize ) hi = netsize;
j = i + 1;
k = i - 1;
q = radpower;
register int j = i + 1;
register int k = i - 1;
register int *q = radpower;
while(( j < hi ) || ( k > lo ))
{
a = (*(++q));
register int a = (*(++q));
register int *p;
if( j < hi )
{
@@ -357,24 +343,20 @@ static void alterneigh( int rad, int i, int r, int g, int b )
// Main Learning Loop
static void learn( void )
{
register byte *p;
register int i, j, r, g, b;
int radius, rad, alpha, step;
int delta, samplepixels;
byte *lim;
int step;
alphadec = 30 + ((samplefac - 1) / 3);
p = thepicture;
lim = thepicture + lengthcount;
samplepixels = lengthcount / (image.bpp * samplefac);
delta = samplepixels / ncycles;
alpha = initalpha;
radius = initradius;
register byte *p = thepicture;
byte *lim = thepicture + lengthcount;
int samplepixels = lengthcount / (image.bpp * samplefac);
int delta = samplepixels / ncycles;
int alpha = initalpha;
int radius = initradius;
rad = radius >> radiusbiasshift;
int rad = radius >> radiusbiasshift;
if( rad <= 1 ) rad = 0;
for( i = 0; i < rad; i++ )
for( int i = 0; i < rad; i++ )
radpower[i] = alpha * ((( rad * rad - i * i ) * radbias ) / ( rad * rad ));
if( delta <= 0 ) return;
@@ -396,14 +378,14 @@ static void learn( void )
step = prime4 * image.bpp;
}
i = 0;
register int i = 0;
while( i < samplepixels )
{
r = p[0] << netbiasshift;
g = p[1] << netbiasshift;
b = p[2] << netbiasshift;
j = contest( r, g, b );
register int r = p[0] << netbiasshift;
register int g = p[1] << netbiasshift;
register int b = p[2] << netbiasshift;
register int j = contest( r, g, b );
altersingle( alpha, j, r, g, b );
if( rad ) alterneigh( rad, j, r, g, b ); // alter neighbours
@@ -420,7 +402,7 @@ static void learn( void )
rad = radius >> radiusbiasshift;
if( rad <= 1 ) rad = 0;
for( j = 0; j < rad; j++ )
for( int j = 0; j < rad; j++ )
radpower[j] = alpha * ((( rad * rad - j * j ) * radbias ) / ( rad * rad ));
}
}

42
engine/common/imagelib/img_tga.c
View File

@@ -34,19 +34,17 @@ Image_LoadTGA
*/
qboolean Image_LoadTGA( const char *name, const byte *buffer, fs_offset_t filesize )
{
int i, columns, rows, row_inc, row, col;
byte *buf_p, *pixbuf, *targa_rgba;
int columns, rows, row_inc, row, col;
byte *pixbuf;
rgba_t palette[256];
byte red = 0, green = 0, blue = 0, alpha = 0;
int readpixelcount, pixelcount;
uint reflectivity[3] = { 0, 0, 0 };
qboolean compressed;
tga_t targa_header;
if( filesize < sizeof( tga_t ))
return false;
buf_p = (byte *)buffer;
byte *buf_p = (byte *)buffer;
targa_header.id_length = *buf_p++;
targa_header.colormap_type = *buf_p++;
targa_header.image_type = *buf_p++;
@@ -87,7 +85,7 @@ qboolean Image_LoadTGA( const char *name, const byte *buffer, fs_offset_t filesi
}
if( targa_header.colormap_size == 24 )
{
for( i = 0; i < targa_header.colormap_length; i++ )
for( int i = 0; i < targa_header.colormap_length; i++ )
{
palette[i][2] = *buf_p++;
palette[i][1] = *buf_p++;
@@ -97,7 +95,7 @@ qboolean Image_LoadTGA( const char *name, const byte *buffer, fs_offset_t filesi
}
else if( targa_header.colormap_size == 32 )
{
for( i = 0; i < targa_header.colormap_length; i++ )
for( int i = 0; i < targa_header.colormap_length; i++ )
{
palette[i][2] = *buf_p++;
palette[i][1] = *buf_p++;
@@ -134,7 +132,7 @@ qboolean Image_LoadTGA( const char *name, const byte *buffer, fs_offset_t filesi
rows = targa_header.height;
image.size = image.width * image.height * 4;
targa_rgba = image.rgba = Mem_Malloc( host.imagepool, image.size );
byte *targa_rgba = image.rgba = Mem_Malloc( host.imagepool, image.size );
// if bit 5 of attributes isn't set, the image has been stored from bottom to top
if( !Image_CheckFlag( IL_DONTFLIP_TGA ) && targa_header.attributes & 0x20 )
@@ -148,11 +146,11 @@ qboolean Image_LoadTGA( const char *name, const byte *buffer, fs_offset_t filesi
row_inc = -columns * 4 * 2;
}
compressed = ( targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11 );
qboolean compressed = ( targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11 );
for( row = col = 0; row < rows; )
{
pixelcount = 0x10000;
readpixelcount = 0x10000;
int pixelcount = 0x10000;
int readpixelcount = 0x10000;
if( compressed )
{
@@ -245,9 +243,7 @@ Image_SaveTGA
*/
qboolean Image_SaveTGA( const char *name, rgbdata_t *pix )
{
int y, outsize, pixel_size;
const uint8_t *bufend, *in;
uint8_t *buffer, *out;
int pixel_size;
tga_t targa_header = {0};
const char comment[] = "Generated by Xash ImageLib";
@@ -269,11 +265,11 @@ qboolean Image_SaveTGA( const char *name, rgbdata_t *pix )
return false;
}
outsize = pix->width * pix->height * pixel_size;
int outsize = pix->width * pix->height * pixel_size;
outsize += sizeof( tga_t );
outsize += sizeof( comment ) - 1;
buffer = (uint8_t *)Mem_Malloc( host.imagepool, outsize );
uint8_t *buffer = (uint8_t *)Mem_Malloc( host.imagepool, outsize );
// prepare header
targa_header.id_length = sizeof( comment ) - 1; // tga comment length
@@ -292,7 +288,7 @@ qboolean Image_SaveTGA( const char *name, rgbdata_t *pix )
targa_header.attributes = 0;
}
out = buffer;
uint8_t *out = buffer;
le_struct_swap( tga_swap, &targa_header );
memcpy( out, &targa_header, sizeof( tga_t ) );
@@ -306,10 +302,10 @@ qboolean Image_SaveTGA( const char *name, rgbdata_t *pix )
case PF_RGB_24:
case PF_RGBA_32:
// swap rgba to bgra and flip upside down
for( y = pix->height - 1; y >= 0; y-- )
for( int y = pix->height - 1; y >= 0; y-- )
{
in = pix->buffer + y * pix->width * pixel_size;
bufend = in + pix->width * pixel_size;
const uint8_t *in = pix->buffer + y * pix->width * pixel_size;
const uint8_t *bufend = in + pix->width * pixel_size;
for( ; in < bufend; in += pixel_size )
{
*out++ = in[2];
@@ -323,10 +319,10 @@ qboolean Image_SaveTGA( const char *name, rgbdata_t *pix )
case PF_BGR_24:
case PF_BGRA_32:
// flip upside down
for( y = pix->height - 1; y >= 0; y-- )
for( int y = pix->height - 1; y >= 0; y-- )
{
in = pix->buffer + y * pix->width * pixel_size;
bufend = in + pix->width * pixel_size;
const uint8_t *in = pix->buffer + y * pix->width * pixel_size;
const uint8_t *bufend = in + pix->width * pixel_size;
for( ; in < bufend; in += pixel_size )
{
*out++ = in[0];

195
engine/common/imagelib/img_utils.c
View File

@@ -174,9 +174,7 @@ void Image_Shutdown( void )
byte *Image_Copy( size_t size )
{
byte *out;
out = Mem_Realloc( host.imagepool, image.tempbuffer, size );
byte *out = Mem_Realloc( host.imagepool, image.tempbuffer, size );
image.tempbuffer = NULL;
return out;
@@ -319,17 +317,16 @@ static void Image_SetPalette( const byte *pal, uint *d_table )
static void Image_ConvertPalTo24bit( rgbdata_t *pic )
{
byte *pal32, *pal24;
byte *converted;
int i;
byte *pal24;
if( pic->type == PF_INDEXED_24 )
return; // does nothing
byte *converted;
pal24 = converted = Mem_Malloc( host.imagepool, 768 );
pal32 = pic->palette;
byte *pal32 = pic->palette;
for( i = 0; i < 256; i++, pal24 += 3, pal32 += 4 )
for( int i = 0; i < 256; i++, pal24 += 3, pal32 += 4 )
{
pal24[0] = pal32[0];
pal24[1] = pal32[1];
@@ -436,27 +433,22 @@ void Image_GetPaletteLMP( const byte *pal, int rendermode )
void Image_PaletteHueReplace( byte *palSrc, int newHue, int start, int end, int pal_size )
{
float r, g, b;
float maxcol, mincol;
float hue, val, sat;
int i;
hue = (float)(newHue * ( 360.0f / 255 ));
float hue = (float)(newHue * ( 360.0f / 255 ));
pal_size = bound( 3, pal_size, 4 );
for( i = start; i <= end; i++ )
for( int i = start; i <= end; i++ )
{
r = palSrc[i*pal_size+0];
g = palSrc[i*pal_size+1];
b = palSrc[i*pal_size+2];
float r = palSrc[i*pal_size+0];
float g = palSrc[i*pal_size+1];
float b = palSrc[i*pal_size+2];
maxcol = Q_max( Q_max( r, g ), b ) / 255.0f;
mincol = Q_min( Q_min( r, g ), b ) / 255.0f;
float maxcol = Q_max( Q_max( r, g ), b ) / 255.0f;
float mincol = Q_min( Q_min( r, g ), b ) / 255.0f;
if( maxcol == 0 ) continue;
val = maxcol;
sat = (maxcol - mincol) / maxcol;
float val = maxcol;
float sat = (maxcol - mincol) / maxcol;
mincol = val * (1.0f - sat);
@@ -512,10 +504,9 @@ void Image_PaletteHueReplace( byte *palSrc, int newHue, int start, int end, int
static void Image_PaletteTranslate( byte *palSrc, int top, int bottom, int pal_size )
{
byte dst[256], src[256];
int i;
pal_size = bound( 3, pal_size, 4 );
for( i = 0; i < 256; i++ )
for( int i = 0; i < 256; i++ )
src[i] = i;
memcpy( dst, src, 256 );
@@ -526,7 +517,7 @@ static void Image_PaletteTranslate( byte *palSrc, int top, int bottom, int pal_s
}
else
{
for( i = 0; i < 16; i++ )
for( int i = 0; i < 16; i++ )
dst[SHIRT_HUE_START+i] = src[top + 15 - i];
}
@@ -536,12 +527,12 @@ static void Image_PaletteTranslate( byte *palSrc, int top, int bottom, int pal_s
}
else
{
for( i = 0; i < 16; i++ )
for( int i = 0; i < 16; i++ )
dst[PANTS_HUE_START + i] = src[bottom + 15 - i];
}
// last color isn't changed
for( i = 0; i < 255; i++ )
for( int i = 0; i < 255; i++ )
{
palSrc[i*pal_size+0] = palette_q1[dst[i]*3+0];
palSrc[i*pal_size+1] = palette_q1[dst[i]*3+1];
@@ -574,8 +565,6 @@ qboolean Image_Copy8bitRGBA( const byte *in, byte *out, int pixels )
{
int *iout = (int *)out;
byte *fin = (byte *)in;
byte *col;
int i;
if( !in || !image.d_currentpal )
return false;
@@ -583,14 +572,14 @@ qboolean Image_Copy8bitRGBA( const byte *in, byte *out, int pixels )
// this is a base image with luma - clear luma pixels
if( image.flags & IMAGE_HAS_LUMA )
{
for( i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
fin[i] = fin[i] < 224 ? fin[i] : image.black_pixel;
}
// check for color
for( i = 0; i < 256; i++ )
for( int i = 0; i < 256; i++ )
{
col = (byte *)&image.d_currentpal[i];
byte *col = (byte *)&image.d_currentpal[i];
if( col[0] != col[1] || col[1] != col[2] )
{
image.flags |= IMAGE_HAS_COLOR;
@@ -641,14 +630,15 @@ qboolean Image_Copy8bitRGBA( const byte *in, byte *out, int pixels )
static void Image_Resample32LerpLine( const byte *in, byte *out, int inwidth, int outwidth )
{
int j, xi, oldx = 0, f, fstep, endx, lerp;
int oldx = 0;
fstep = (int)(inwidth * 65536.0f / outwidth);
endx = (inwidth-1);
int fstep = (int)(inwidth * 65536.0f / outwidth);
int endx = (inwidth-1);
int j, f;
for( j = 0, f = 0; j < outwidth; j++, f += fstep )
{
xi = f>>16;
int xi = f>>16;
if( xi != oldx )
{
in += (xi - oldx) * 4;
@@ -656,7 +646,7 @@ static void Image_Resample32LerpLine( const byte *in, byte *out, int inwidth, in
}
if( xi < endx )
{
lerp = f & 0xFFFF;
int lerp = f & 0xFFFF;
*out++ = (byte)((((in[4] - in[0]) * lerp)>>16) + in[0]);
*out++ = (byte)((((in[5] - in[1]) * lerp)>>16) + in[1]);
*out++ = (byte)((((in[6] - in[2]) * lerp)>>16) + in[2]);
@@ -674,14 +664,15 @@ static void Image_Resample32LerpLine( const byte *in, byte *out, int inwidth, in
static void Image_Resample24LerpLine( const byte *in, byte *out, int inwidth, int outwidth )
{
int j, xi, oldx = 0, f, fstep, endx, lerp;
int oldx = 0;
fstep = (int)(inwidth * 65536.0f / outwidth);
endx = (inwidth-1);
int fstep = (int)(inwidth * 65536.0f / outwidth);
int endx = (inwidth-1);
int j, f;
for( j = 0, f = 0; j < outwidth; j++, f += fstep )
{
xi = f>>16;
int xi = f>>16;
if( xi != oldx )
{
@@ -691,7 +682,7 @@ static void Image_Resample24LerpLine( const byte *in, byte *out, int inwidth, in
if( xi < endx )
{
lerp = f & 0xFFFF;
int lerp = f & 0xFFFF;
*out++ = (byte)((((in[3] - in[0]) * lerp)>>16) + in[0]);
*out++ = (byte)((((in[4] - in[1]) * lerp)>>16) + in[1]);
*out++ = (byte)((((in[5] - in[2]) * lerp)>>16) + in[2]);
@@ -707,20 +698,17 @@ static void Image_Resample24LerpLine( const byte *in, byte *out, int inwidth, in
static void Image_Resample32Lerp( const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight )
{
const byte *inrow;
int i, j, r, yi, oldy = 0, f, fstep, lerp, endy = (inheight - 1);
int i, j, r, yi, oldy = 0, f, lerp, endy = (inheight - 1);
int inwidth4 = inwidth * 4;
int outwidth4 = outwidth * 4;
byte *out = (byte *)outdata;
byte *resamplerow1;
byte *resamplerow2;
fstep = (int)(inheight * 65536.0f / outheight);
int fstep = (int)(inheight * 65536.0f / outheight);
resamplerow1 = (byte *)Mem_Malloc( host.imagepool, outwidth * 4 * 2);
resamplerow2 = resamplerow1 + outwidth * 4;
byte *resamplerow1 = (byte *)Mem_Malloc( host.imagepool, outwidth * 4 * 2);
byte *resamplerow2 = resamplerow1 + outwidth * 4;
inrow = (const byte *)indata;
const byte *inrow = (const byte *)indata;
Image_Resample32LerpLine( inrow, resamplerow1, inwidth, outwidth );
Image_Resample32LerpLine( inrow + inwidth4, resamplerow2, inwidth, outwidth );
@@ -815,17 +803,15 @@ static void Image_Resample32Lerp( const void *indata, int inwidth, int inheight,
static void Image_Resample32Nolerp( const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight )
{
int i, j;
uint frac, fracstep;
int *inrow, *out = (int *)outdata; // relies on int being 4 bytes
int *out = (int *)outdata; // relies on int being 4 bytes
fracstep = inwidth * 0x10000 / outwidth;
uint fracstep = inwidth * 0x10000 / outwidth;
for( i = 0; i < outheight; i++)
for( int i = 0; i < outheight; i++)
{
inrow = (int *)indata + inwidth * (i * inheight / outheight);
frac = fracstep>>1;
j = outwidth - 4;
int *inrow = (int *)indata + inwidth * (i * inheight / outheight);
uint frac = fracstep>>1;
int j = outwidth - 4;
while( j >= 0 )
{
@@ -854,21 +840,18 @@ static void Image_Resample32Nolerp( const void *indata, int inwidth, int inheigh
static void Image_Resample24Lerp( const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight )
{
const byte *inrow;
int i, j, r, yi, oldy, f, fstep, lerp, endy = (inheight - 1);
int i, j, r, yi, f, lerp, endy = (inheight - 1);
int inwidth3 = inwidth * 3;
int outwidth3 = outwidth * 3;
byte *out = (byte *)outdata;
byte *resamplerow1;
byte *resamplerow2;
fstep = (int)(inheight * 65536.0f / outheight);
int fstep = (int)(inheight * 65536.0f / outheight);
resamplerow1 = (byte *)Mem_Malloc( host.imagepool, outwidth * 3 * 2 );
resamplerow2 = resamplerow1 + outwidth*3;
byte *resamplerow1 = (byte *)Mem_Malloc( host.imagepool, outwidth * 3 * 2 );
byte *resamplerow2 = resamplerow1 + outwidth*3;
inrow = (const byte *)indata;
oldy = 0;
const byte *inrow = (const byte *)indata;
int oldy = 0;
Image_Resample24LerpLine( inrow, resamplerow1, inwidth, outwidth );
Image_Resample24LerpLine( inrow + inwidth3, resamplerow2, inwidth, outwidth );
@@ -955,17 +938,17 @@ static void Image_Resample24Lerp( const void *indata, int inwidth, int inheight,
static void Image_Resample24Nolerp( const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight )
{
uint frac, fracstep;
int i, j, f, inwidth3 = inwidth * 3;
byte *inrow, *out = (byte *)outdata;
int inwidth3 = inwidth * 3;
byte *out = (byte *)outdata;
fracstep = inwidth * 0x10000 / outwidth;
uint fracstep = inwidth * 0x10000 / outwidth;
for( i = 0; i < outheight; i++)
for( int i = 0; i < outheight; i++)
{
inrow = (byte *)indata + inwidth3 * (i * inheight / outheight);
frac = fracstep>>1;
j = outwidth - 4;
byte *inrow = (byte *)indata + inwidth3 * (i * inheight / outheight);
uint frac = fracstep>>1;
int j = outwidth - 4;
int f;
while( j >= 0 )
{
@@ -1021,20 +1004,17 @@ static void Image_Resample24Nolerp( const void *indata, int inwidth, int inheigh
static void Image_Resample8Nolerp( const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight )
{
int i, j;
byte *in, *inrow;
uint frac, fracstep;
byte *out = (byte *)outdata;
in = (byte *)indata;
fracstep = inwidth * 0x10000 / outwidth;
byte *in = (byte *)indata;
uint fracstep = inwidth * 0x10000 / outwidth;
for( i = 0; i < outheight; i++, out += outwidth )
for( int i = 0; i < outheight; i++, out += outwidth )
{
inrow = in + inwidth*(i*inheight/outheight);
frac = fracstep>>1;
byte *inrow = in + inwidth*(i*inheight/outheight);
uint frac = fracstep>>1;
for( j = 0; j < outwidth; j++ )
for( int j = 0; j < outwidth; j++ )
{
out[j] = inrow[frac>>16];
frac += fracstep;
@@ -1094,7 +1074,7 @@ Image_Flip
*/
byte *Image_FlipInternal( const byte *in, word *srcwidth, word *srcheight, int type, int flags )
{
int i, x, y;
int x, y;
word width = *srcwidth;
word height = *srcheight;
int samples = PFDesc[type].bpp;
@@ -1106,7 +1086,6 @@ byte *Image_FlipInternal( const byte *in, word *srcwidth, word *srcheight, int t
int row_ofs = ( flip_y ? ( height - 1 ) * width * samples : 0 );
int col_ofs = ( flip_x ? ( width - 1 ) * samples : 0 );
const byte *p, *line;
byte *out;
// nothing to process
if( !FBitSet( flags, IMAGE_FLIP_X|IMAGE_FLIP_Y|IMAGE_ROT_90 ))
@@ -1126,20 +1105,20 @@ byte *Image_FlipInternal( const byte *in, word *srcwidth, word *srcheight, int t
return (byte *)in;
}
out = image.tempbuffer;
byte *out = image.tempbuffer;
if( flip_i )
{
for( x = 0, line = in + col_ofs; x < width; x++, line += col_inc )
for( y = 0, p = line + row_ofs; y < height; y++, p += row_inc, out += samples )
for( i = 0; i < samples; i++ )
for( int i = 0; i < samples; i++ )
out[i] = p[i];
}
else
{
for( y = 0, line = in + row_ofs; y < height; y++, line += row_inc )
for( x = 0, p = line + col_ofs; x < width; x++, p += col_inc, out += samples )
for( i = 0; i < samples; i++ )
for( int i = 0; i < samples; i++ )
out[i] = p[i];
}
@@ -1161,7 +1140,6 @@ byte *Image_FlipInternal( const byte *in, word *srcwidth, word *srcheight, int t
static byte *Image_MakeLuma( byte *fin, int width, int height, int type, int flags )
{
byte *out;
int i;
if( !FBitSet( flags, IMAGE_HAS_LUMA ))
return (byte *)fin;
@@ -1171,7 +1149,7 @@ static byte *Image_MakeLuma( byte *fin, int width, int height, int type, int fla
case PF_INDEXED_24:
case PF_INDEXED_32:
out = image.tempbuffer = Mem_Realloc( host.imagepool, image.tempbuffer, width * height );
for( i = 0; i < width * height; i++ )
for( int i = 0; i < width * height; i++ )
*out++ = fin[i] >= 224 ? fin[i] : image.black_pixel;
break;
default:
@@ -1216,15 +1194,12 @@ force to unpack any image to 32-bit buffer
*/
static qboolean Image_Decompress( const byte *data )
{
byte *fin, *fout;
int i, size;
if( !data ) return false;
fin = (byte *)data;
byte *fin = (byte *)data;
size = image.width * image.height * 4;
int size = image.width * image.height * 4;
image.tempbuffer = Mem_Realloc( host.imagepool, image.tempbuffer, size );
fout = image.tempbuffer;
byte *fout = image.tempbuffer;
switch( PFDesc[image.type].format )
{
@@ -1243,7 +1218,7 @@ static qboolean Image_Decompress( const byte *data )
return false;
break;
case PF_BGR_24:
for (i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
{
fout[(i<<2)+0] = fin[i*3+2];
fout[(i<<2)+1] = fin[i*3+1];
@@ -1252,7 +1227,7 @@ static qboolean Image_Decompress( const byte *data )
}
break;
case PF_RGB_24:
for (i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
{
fout[(i<<2)+0] = fin[i*3+0];
fout[(i<<2)+1] = fin[i*3+1];
@@ -1261,7 +1236,7 @@ static qboolean Image_Decompress( const byte *data )
}
break;
case PF_BGRA_32:
for( i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
{
fout[i*4+0] = fin[i*4+2];
fout[i*4+1] = fin[i*4+1];
@@ -1308,12 +1283,11 @@ static rgbdata_t *Image_DecompressInternal( rgbdata_t *pic )
static rgbdata_t *Image_LightGamma( rgbdata_t *pic )
{
byte *in = (byte *)pic->buffer;
int i;
if( pic->type != PF_RGBA_32 )
return pic;
for( i = 0; i < pic->width * pic->height; i++, in += 4 )
for( int i = 0; i < pic->width * pic->height; i++, in += 4 )
{
in[0] = LightToTexGamma( in[0] );
in[1] = LightToTexGamma( in[1] );
@@ -1483,22 +1457,17 @@ void Image_GenerateMipmaps( const byte *source, int width, int height, byte *mip
{ width / 8, height / 8 }
};
byte *mipmaps[3] = { mip1, mip2, mip3 };
int m;
for( m = 0; m < 3; ++m )
for( int m = 0; m < 3; ++m )
{
int mw, mh, step, y;
if( !mipmaps[m] )
continue;
mw = sizes[m][0];
mh = sizes[m][1];
step = 1 << ( m + 1 );
for( y = 0; y < mh; ++y )
int mw = sizes[m][0];
int mh = sizes[m][1];
int step = 1 << ( m + 1 );
for( int y = 0; y < mh; ++y )
{
int x;
for( x = 0; x < mw; ++x )
for( int x = 0; x < mw; ++x )
{
mipmaps[m][y * mw + x] = source[( y * step ) * width + ( x * step )];
}

105
engine/common/imagelib/img_wad.c
View File

@@ -124,9 +124,6 @@ Image_LoadFNT
qboolean Image_LoadFNT( const char *name, const byte *buffer, fs_offset_t filesize )
{
qfont_t font;
const byte *pal, *fin;
size_t size;
int numcolors;
if( image.hint == IL_HINT_Q1 )
return false; // Quake1 doesn't have qfonts
@@ -138,7 +135,7 @@ qboolean Image_LoadFNT( const char *name, const byte *buffer, fs_offset_t filesi
le_struct_swap( qfont_swap, &font );
// last sixty four bytes - what the hell ????
size = sizeof( qfont_t ) - 4 + ( font.height * font.width * QCHAR_WIDTH ) + sizeof( short ) + 768 + 64;
size_t size = sizeof( qfont_t ) - 4 + ( font.height * font.width * QCHAR_WIDTH ) + sizeof( short ) + 768 + 64;
if( size != filesize )
{
@@ -156,9 +153,9 @@ qboolean Image_LoadFNT( const char *name, const byte *buffer, fs_offset_t filesi
if( !Image_LumpValidSize( name ))
return false;
fin = buffer + sizeof( font ) - 4;
pal = fin + (image.width * image.height);
numcolors = pal[0] | (pal[1] << 8);
const byte *fin = buffer + sizeof( font ) - 4;
const byte *pal = fin + (image.width * image.height);
int numcolors = pal[0] | (pal[1] << 8);
pal += sizeof( short );
if( numcolors == 768 || numcolors == 256 )
@@ -198,18 +195,13 @@ Image_LoadMDL
*/
qboolean Image_LoadMDL( const char *name, const byte *buffer, fs_offset_t filesize )
{
byte *fin;
size_t pixels;
mstudiotexture_t *pin;
int flags;
pin = (mstudiotexture_t *)buffer;
flags = pin->flags;
mstudiotexture_t *pin = (mstudiotexture_t *)buffer;
int flags = pin->flags;
image.width = pin->width;
image.height = pin->height;
pixels = image.width * image.height;
fin = (byte *)g_mdltexdata;
size_t pixels = image.width * image.height;
byte *fin = (byte *)g_mdltexdata;
ASSERT(fin);
g_mdltexdata = NULL;
@@ -250,7 +242,6 @@ qboolean Image_LoadSPR( const char *name, const byte *buffer, fs_offset_t filesi
{
dspriteframe_t pin; // identical for q1\hl sprites
qboolean truecolor = false;
byte *fin;
if( image.hint == IL_HINT_HL )
{
@@ -296,7 +287,7 @@ qboolean Image_LoadSPR( const char *name, const byte *buffer, fs_offset_t filesi
break;
}
fin = (byte *)(buffer + sizeof(dspriteframe_t));
byte *fin = (byte *)(buffer + sizeof(dspriteframe_t));
if( truecolor )
{
@@ -320,7 +311,6 @@ qboolean Image_LoadLMP( const char *name, const byte *buffer, fs_offset_t filesi
lmp_t lmp;
byte *fin, *pal;
int rendermode;
int i, pixels;
if( filesize < sizeof( lmp ))
return false;
@@ -338,7 +328,7 @@ qboolean Image_LoadLMP( const char *name, const byte *buffer, fs_offset_t filesi
fin = (byte *)buffer;
// need to remap transparent color from first to last entry
for( i = 0; i < 16384; i++ ) if( !fin[i] ) fin[i] = 0xFF;
for( int i = 0; i < 16384; i++ ) if( !fin[i] ) fin[i] = 0xFF;
}
else
{
@@ -351,7 +341,7 @@ qboolean Image_LoadLMP( const char *name, const byte *buffer, fs_offset_t filesi
fin += sizeof( lmp );
}
pixels = image.width * image.height;
int pixels = image.width * image.height;
if( filesize < sizeof( lmp ) + pixels )
return false;
@@ -366,7 +356,7 @@ qboolean Image_LoadLMP( const char *name, const byte *buffer, fs_offset_t filesi
// HACKHACK: console background image shouldn't be transparent
if( !Q_stristr( name, "conback" ))
{
for( i = 0; i < pixels; i++ )
for( int i = 0; i < pixels; i++ )
{
if( fin[i] == 255 )
{
@@ -430,7 +420,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
qboolean hl_texture;
byte *fin, *pal;
int ofs[4], rendermode;
int i, pixels, numcolors;
int numcolors;
uint reflectivity[3] = { 0, 0, 0 };
if( filesize < sizeof( mip ))
@@ -446,7 +436,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
return false;
memcpy( ofs, mip.offsets, sizeof( ofs ));
pixels = image.width * image.height;
int pixels = image.width * image.height;
if( image.hint != IL_HINT_Q1 && filesize >= (int)sizeof(mip) + ((pixels * 85)>>6) + sizeof(short) + 768)
{
@@ -489,7 +479,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
// check for luma pixels (but ignore liquid textures because they have no lightmap)
if( mip.name[0] != '*' && mip.name[0] != '!' )
{
for( i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
{
if( fin[i] > 224 )
{
@@ -548,7 +538,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
// don't apply luma to water surfaces because they have no lightmap
if( !image.custom_palette && mip.name[0] != '*' && mip.name[0] != '!' )
{
for( i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
{
if( fin[i] > 224 && fin[i] != 255 )
{
@@ -562,7 +552,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
// Arcane Dimensions has the transparent textures
if( Q_strrchr( name, '{' ))
{
for( i = 0; i < image.width * image.height; i++ )
for( int i = 0; i < image.width * image.height; i++ )
{
if( fin[i] == 255 )
{
@@ -614,7 +604,7 @@ qboolean Image_LoadMIP( const char *name, const byte *buffer, fs_offset_t filesi
else
{
// calc texture reflectivity
for( i = 0; i < 256; i++ )
for( int i = 0; i < 256; i++ )
{
reflectivity[0] += pal[i*3+0];
reflectivity[1] += pal[i*3+1];
@@ -639,8 +629,6 @@ Image_LoadWAD
qboolean Image_LoadWAD( const char *name, const byte *buffer, fs_offset_t filesize )
{
dwadinfo_t whdr;
const unsigned char *mipdata;
int i, j;
if( !buffer || filesize < sizeof( dwadinfo_t ))
return false;
@@ -650,19 +638,13 @@ qboolean Image_LoadWAD( const char *name, const byte *buffer, fs_offset_t filesi
if( whdr.numlumps <= 0 || whdr.infotableofs <= 0 || whdr.infotableofs >= (int)filesize )
return false;
for( i = 0; i < whdr.numlumps; ++i )
for( int i = 0; i < whdr.numlumps; ++i )
{
const unsigned char *pixels, *palette, *use_palette;
unsigned char grad_palette[256 * 3];
dlumpinfo_t lump;
int mip_size;
mip_t mip;
uint32_t width, height, offset0;
uint32_t m0size, m1size, m2size, m3size;
qboolean alpha_mode = false;
unsigned char frontR = 0, frontG = 0, frontB = 0;
float t;
byte idx;
memcpy( &lump, buffer + whdr.infotableofs + i * sizeof( dlumpinfo_t ), sizeof( lump ));
le_struct_swap( dlumpinfo_swap, &lump );
@@ -671,30 +653,30 @@ qboolean Image_LoadWAD( const char *name, const byte *buffer, fs_offset_t filesi
continue;
// get lump data and validate
mipdata = (const unsigned char *)buffer + lump.filepos;
mip_size = lump.disksize;
const unsigned char *mipdata = (const unsigned char *)buffer + lump.filepos;
int mip_size = lump.disksize;
if( lump.filepos < 0 || lump.filepos + mip_size > (int)filesize )
continue;
memcpy( &mip, mipdata, sizeof( mip ));
le_struct_swap( mip_swap, &mip );
width = mip.width;
height = mip.height;
uint32_t width = mip.width;
uint32_t height = mip.height;
if( width <= 0 || height <= 0 || width > 256 || height > 256 )
continue;
offset0 = mip.offsets[0];
uint32_t offset0 = mip.offsets[0];
if( offset0 == 0 || offset0 + width * height > (uint32_t)mip_size )
continue;
pixels = mipdata + offset0;
m0size = width * height;
m1size = m0size / 4;
m2size = m0size / 16;
m3size = m0size / 64;
palette = mipdata + 0x28 + m0size + m1size + m2size + m3size + 2;
use_palette = palette;
const unsigned char *pixels = mipdata + offset0;
uint32_t m0size = width * height;
uint32_t m1size = m0size / 4;
uint32_t m2size = m0size / 16;
uint32_t m3size = m0size / 64;
const unsigned char *palette = mipdata + 0x28 + m0size + m1size + m2size + m3size + 2;
const unsigned char *use_palette = palette;
// handle gradient palette
if( lump.type == TYP_PALETTE )
@@ -704,9 +686,9 @@ qboolean Image_LoadWAD( const char *name, const byte *buffer, fs_offset_t filesi
frontR = frontColorPtr[0];
frontG = frontColorPtr[1];
frontB = frontColorPtr[2];
for( j = 0; j < 256; ++j )
for( int j = 0; j < 256; ++j )
{
t = j / 255.0f;
float t = j / 255.0f;
grad_palette[j * 3 + 0] = (unsigned char)( frontR * t );
grad_palette[j * 3 + 1] = (unsigned char)( frontG * t );
grad_palette[j * 3 + 2] = (unsigned char)( frontB * t );
@@ -726,9 +708,9 @@ qboolean Image_LoadWAD( const char *name, const byte *buffer, fs_offset_t filesi
image.palette = NULL;
// convert indexed pixels to RGBA
for( j = 0; j < (int)( width * height ); ++j )
for( int j = 0; j < (int)( width * height ); ++j )
{
idx = pixels[j];
byte idx = pixels[j];
image.rgba[j * 4 + 0] = use_palette[idx * 3 + 0];
image.rgba[j * 4 + 1] = use_palette[idx * 3 + 1];
image.rgba[j * 4 + 2] = use_palette[idx * 3 + 2];
@@ -749,9 +731,7 @@ Image_SaveWAD
*/
qboolean Image_SaveWAD( const char *name, rgbdata_t *pix )
{
int m0size, m1size, m2size, m3size;
byte *mip1_data = NULL, *mip2_data = NULL, *mip3_data = NULL;
const byte *palette;
byte grad_palette[256 * 3];
file_t *f;
dwadinfo_t header;
@@ -759,7 +739,6 @@ qboolean Image_SaveWAD( const char *name, rgbdata_t *pix )
long infotableofs;
dlumpinfo_t lump;
fs_offset_t pad;
int i;
qboolean result = false;
int lump_type = ( pix->flags & IMAGE_GRADIENT_DECAL ) ? TYP_PALETTE : TYP_MIPTEX;
short palette_size = 256;
@@ -768,12 +747,12 @@ qboolean Image_SaveWAD( const char *name, rgbdata_t *pix )
if( !pix || !pix->buffer )
return false;
palette = pix->palette ? pix->palette : (const byte *)image.palette;
const byte *palette = pix->palette ? pix->palette : (const byte *)image.palette;
m0size = pix->width * pix->height;
m1size = m0size / 4;
m2size = m0size / 16;
m3size = m0size / 64;
int m0size = pix->width * pix->height;
int m1size = m0size / 4;
int m2size = m0size / 16;
int m3size = m0size / 64;
mip1_data = (byte *)Mem_Malloc( host.imagepool, m1size );
mip2_data = (byte *)Mem_Malloc( host.imagepool, m2size );
@@ -815,7 +794,7 @@ qboolean Image_SaveWAD( const char *name, rgbdata_t *pix )
if( lump_type == TYP_PALETTE )
{
const byte *frontColorPtr = palette + 255 * 3;
for( i = 0; i < 256; ++i )
for( int i = 0; i < 256; ++i )
{
float t = i / 255.0f;
grad_palette[i * 3 + 0] = (byte)( frontColorPtr[0] * t );
@@ -831,7 +810,7 @@ qboolean Image_SaveWAD( const char *name, rgbdata_t *pix )
// padding up to a multiple of 4
pad = (( FS_Tell( f ) + 3 ) & ~3 ) - FS_Tell( f );
for( i = 0; i < pad; ++i )
for( int i = 0; i < pad; ++i )
FS_Write( f, (const void *)&(char){0}, 1 );
infotableofs = FS_Tell( f );

20
engine/common/infostring.c
View File

@@ -35,15 +35,13 @@ void Info_Print( const char *s )
{
char key[MAX_KV_SIZE];
char value[MAX_KV_SIZE];
int l, count;
char *o;
if( *s == '\\' ) s++;
while( *s )
{
count = 0;
o = key;
int count = 0;
char *o = key;
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' )
{
@@ -51,7 +49,7 @@ void Info_Print( const char *s )
count++;
}
l = o - key;
int l = o - key;
if( l < 20 )
{
memset( o, ' ', 20 - l );
@@ -93,15 +91,13 @@ qboolean Info_IsValid( const char *s )
{
char key[MAX_KV_SIZE];
char value[MAX_KV_SIZE];
int count;
char *o;
if( *s == '\\' ) s++;
while( *s )
{
count = 0;
o = key;
int count = 0;
char *o = key;
while( count < (MAX_KV_SIZE - 1) && *s && *s != '\\' )
{
@@ -144,15 +140,13 @@ void Info_WriteVars( file_t *f )
char pkey[MAX_SERVERINFO_STRING];
static char value[4][MAX_SERVERINFO_STRING]; // use two buffers so compares work without stomping on each other
static int valueindex;
convar_t *pcvar;
char *o;
valueindex = (valueindex + 1) % 4;
if( *s == '\\' ) s++;
while( 1 )
{
o = pkey;
char *o = pkey;
while( *s != '\\' )
{
if( !*s ) return;
@@ -170,7 +164,7 @@ void Info_WriteVars( file_t *f )
}
*o = 0;
pcvar = Cvar_FindVar( pkey );
convar_t *pcvar = Cvar_FindVar( pkey );
if( !pcvar && pkey[0] != '*' ) // don't store out star keys
FS_Printf( f, "setinfo \"%s\" \"%s\"\n", pkey, value[valueindex] );

54
engine/common/ipv6text.c
View File

@@ -15,11 +15,9 @@ void IPv6IPToString( char *pszOutText, const unsigned char *ip )
// If there's a tie, we want the leftmost one.
int idxLongestRunStart = -1;
int nLongestRun = 1; // It must be at least 2 quads in a row, a single 0 must not be compressed
int nCurrentRun = 0, idxQuad;
char *p;
qboolean bNeedColon;
int nCurrentRun = 0;
for ( idxQuad = 0 ; idxQuad < 8 ; ++idxQuad )
for ( int idxQuad = 0 ; idxQuad < 8 ; ++idxQuad )
{
// Zero
if ( ip[idxQuad*2] || ip[idxQuad*2 + 1] )
@@ -42,9 +40,9 @@ void IPv6IPToString( char *pszOutText, const unsigned char *ip )
}
// Print the quads
p = pszOutText;
idxQuad = 0;
bNeedColon = false;
char *p = pszOutText;
int idxQuad = 0;
qboolean bNeedColon = false;
while ( idxQuad < 8 )
{
// Run of compressed zeros?
@@ -59,7 +57,6 @@ void IPv6IPToString( char *pszOutText, const unsigned char *ip )
{
// Lowercase hex digits, with leading zeros omitted
static const char hexdigits[] = "0123456789abcdef";
unsigned quad;
// Colon to separate from previous, unless
// we are first or immediately follow compressed zero "::"
@@ -70,7 +67,7 @@ void IPv6IPToString( char *pszOutText, const unsigned char *ip )
bNeedColon = true;
// Assemble 16-bit quad value from the two bytes
quad = ( (unsigned)ip[idxQuad*2] << 8U ) | ip[idxQuad*2 + 1];
unsigned quad = ( (unsigned)ip[idxQuad*2] << 8U ) | ip[idxQuad*2 + 1];
// Manually do the hex number formatting.
if ( quad >= 0x0010 )
@@ -143,14 +140,9 @@ static bool ParseIPv6Addr_IsSpace( char c )
}
bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, uint32_t *pOutScope )
{
unsigned char *d, *pZeroFill, *pEndIP;
const char *s;
qboolean bQuadMustFollow;
int nPort;
while ( ParseIPv6Addr_IsSpace( *pszText ) )
++pszText;
s = pszText;
const char *s = pszText;
// Skip opening bracket, if present
if ( *s == '[' )
@@ -161,10 +153,10 @@ bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, u
}
// Special case for leading "::"
bQuadMustFollow = true;
d = pOutIP;
pZeroFill = NULL;
pEndIP = pOutIP + 16;
qboolean bQuadMustFollow = true;
unsigned char *d = pOutIP;
unsigned char *pZeroFill = NULL;
unsigned char *pEndIP = pOutIP + 16;
if ( s[0] == ':' && s[1] == ':' )
{
pZeroFill = d;
@@ -177,8 +169,6 @@ bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, u
{
// Next thing must be a quad, or end of input. Is it a quad?
int quadDigit = ParseIPv6Addr_HexDigitVal( *s );
const char *pszStartQuad;
int quad;
if ( quadDigit < 0 )
{
@@ -191,9 +181,9 @@ bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, u
if ( d >= pEndIP )
return false;
pszStartQuad = s;
const char *pszStartQuad = s;
++s;
quad = quadDigit;
int quad = quadDigit;
// Now parse up to three additional characters
quadDigit = ParseIPv6Addr_HexDigitVal( *s );
@@ -233,12 +223,11 @@ bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, u
// Parse 1-3 decimal digits
int octet = ParseIPv6Addr_DecimalDigitVal( *s );
int dig;
if ( octet < 0 )
return false;
++s;
dig = ParseIPv6Addr_DecimalDigitVal( *s );
int dig = ParseIPv6Addr_DecimalDigitVal( *s );
if ( dig >= 0 )
{
++s;
@@ -340,16 +329,13 @@ bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, u
if ( *s == '%' )
{
// Parse scope number
uint32_t unScope = 0;
int nScopeDigit;
++s;
nScopeDigit = ParseIPv6Addr_DecimalDigitVal( *s );
// Parse scope number
int nScopeDigit = ParseIPv6Addr_DecimalDigitVal( *s );
if ( nScopeDigit < 0 )
return false;
unScope = (uint32_t)nScopeDigit;
uint32_t unScope = (uint32_t)nScopeDigit;
for (;;)
{
++s;
@@ -418,17 +404,15 @@ bool ParseIPv6Addr( const char *pszText, unsigned char *pOutIP, int *pOutPort, u
return false;
// Parse port number
nPort = ParseIPv6Addr_DecimalDigitVal( *s );
int nPort = ParseIPv6Addr_DecimalDigitVal( *s );
if ( nPort < 0 )
return false;
for (;;)
{
int portDigit;
++s;
if ( *s == '\0' || ParseIPv6Addr_IsSpace( *s ) )
break;
portDigit = ParseIPv6Addr_DecimalDigitVal( *s );
int portDigit = ParseIPv6Addr_DecimalDigitVal( *s );
if ( portDigit < 0 )
return false;
nPort = nPort * 10 + portDigit;

48
engine/common/lib_common.c
View File

@@ -46,13 +46,13 @@ void *COM_FunctionFromName_SR( void *hInstance, const char *pName )
#endif
#if XASH_POSIX
size_t numfuncs, i;
void *f = NULL;
size_t numfuncs;
char **funcs = COM_ConvertToLocalPlatform( MANGLE_ITANIUM, pName, &numfuncs );
if( funcs )
{
for( i = 0; i < numfuncs; i++ )
void *f = NULL;
for( size_t i = 0; i < numfuncs; i++ )
{
if( !f )
f = COM_FunctionFromName( hInstance, funcs[i] );
@@ -85,13 +85,10 @@ const char *COM_OffsetNameForFunction( void *function )
dll_user_t *FS_FindLibrary( const char *dllname, qboolean directpath )
{
dll_user_t *p;
fs_dllinfo_t dllInfo;
// no fs loaded yet, but let engine find fs
if( !g_fsapi.FindLibrary )
{
p = Mem_Calloc( host.mempool, sizeof( dll_user_t ));
dll_user_t *p = Mem_Calloc( host.mempool, sizeof( dll_user_t ));
Q_strncpy( p->shortPath, dllname, sizeof( p->shortPath ));
Q_strncpy( p->fullPath, dllname, sizeof( p->fullPath ));
Q_strncpy( p->dllName, dllname, sizeof( p->dllName ));
@@ -99,13 +96,15 @@ dll_user_t *FS_FindLibrary( const char *dllname, qboolean directpath )
return p;
}
fs_dllinfo_t dllInfo;
// fs can't find library
if( !g_fsapi.FindLibrary( dllname, directpath, &dllInfo ))
return NULL;
// NOTE: for libraries we not fail even if search is NULL
// let the OS find library himself
p = Mem_Calloc( host.mempool, sizeof( dll_user_t ));
dll_user_t *p = Mem_Calloc( host.mempool, sizeof( dll_user_t ));
Q_strncpy( p->shortPath, dllInfo.shortPath, sizeof( p->shortPath ));
Q_strncpy( p->fullPath, dllInfo.fullPath, sizeof( p->fullPath ));
Q_strncpy( p->dllName, dllname, sizeof( p->dllName ));
@@ -279,12 +278,12 @@ static EFunctionMangleType COM_DetectMangleType( const char *str )
char *COM_GetMSVCName( const char *in_name )
{
static string out_name;
char *pos;
static string out_name;
if( in_name[0] == '?' ) // is this a MSVC C++ mangled name?
{
if(( pos = Q_strstr( in_name, "@@" )) != NULL )
char *pos = Q_strstr( in_name, "@@" );
if( pos != NULL )
{
ptrdiff_t len = pos - in_name;
@@ -367,16 +366,12 @@ invalid_format:
char **COM_ConvertToLocalPlatform( EFunctionMangleType to, const char *from, size_t *numfuncs )
{
string symbols[MAX_NESTED_NAMESPACES], temp, temp2;
const char *prev;
const char *postfix[3];
int i = 0;
char **ret;
// TODO:
if( to == MANGLE_MSVC )
return NULL;
const char *postfix[3];
switch( to )
{
case MANGLE_ITANIUM:
@@ -389,7 +384,9 @@ char **COM_ConvertToLocalPlatform( EFunctionMangleType to, const char *from, siz
return NULL;
}
prev = from;
string symbols[MAX_NESTED_NAMESPACES];
const char *prev = from;
int i;
for( i = 0; i < MAX_NESTED_NAMESPACES; i++ )
{
@@ -415,8 +412,9 @@ char **COM_ConvertToLocalPlatform( EFunctionMangleType to, const char *from, siz
// only three possible variations
*numfuncs = ARRAYSIZE( postfix );
ret = Z_Malloc( sizeof( char * ) * ARRAYSIZE( postfix ) );
char **ret = Z_Malloc( sizeof( char * ) * ARRAYSIZE( postfix ) );
string temp, temp2;
Q_strncpy( temp, "_ZN", sizeof( temp ));
for( ; i >= 0; i-- )
@@ -492,9 +490,8 @@ static void Test_GetMSVCName( void )
"?foo@@", "foo", // not an error?
"?foo@bar@baz@@gotstrippedanyway","foo@bar@baz"
};
int i;
for( i = 0; i < ARRAYSIZE( symbols ); i += 2 )
for( int i = 0; i < ARRAYSIZE( symbols ); i += 2 )
{
Msg( "Checking if MSVC '%s' converts to '%s'...\n", symbols[i], symbols[i+1] );
@@ -519,9 +516,8 @@ static void Test_GetItaniumName( void )
"_ZN3fooEv", "foo", // not possible?
"_ZN3baz3bar3fooEdontcare", "foo@bar@baz",
};
int i;
for( i = 0; i < ARRAYSIZE( symbols ); i += 2 )
for( int i = 0; i < ARRAYSIZE( symbols ); i += 2 )
{
Msg( "Checking if Itanium '%s' converts to '%s'...\n", symbols[i], symbols[i+1] );
@@ -538,17 +534,15 @@ static void Test_ConvertFromValveToLocal( void )
"xash3d@fwgs", "_ZN4fwgs6xash3d",
"foo@bar@bazz", "_ZN4bazz3bar3foo"
};
int i;
for( i = 0; i < ARRAYSIZE( symbols ); i += 2 )
for( int i = 0; i < ARRAYSIZE( symbols ); i += 2 )
{
char **ret;
size_t numfuncs;
size_t symlen = Q_strlen( symbols[i + 1] );
Msg( "Checking if Valve '%s' converts to Itanium '%s'...\n", symbols[i], symbols[i+1] );
ret = COM_ConvertToLocalPlatform( MANGLE_ITANIUM, symbols[i], &numfuncs );
char **ret = COM_ConvertToLocalPlatform( MANGLE_ITANIUM, symbols[i], &numfuncs );
TASSERT( numfuncs == 3 );
TASSERT( !Q_strncmp( ret[0], symbols[i+1], symlen ));

69
engine/common/masterlist.c
View File

@@ -45,14 +45,11 @@ static CVAR_DEFINE_AUTO( sv_verbose_heartbeats, "0", 0, "print every heartbeat t
static size_t NET_BuildMasterServerScanRequest( char *buf, size_t size, uint32_t key, qboolean nat, const char *filter, connprotocol_t proto )
{
size_t remaining;
char *info, temp[32];
// TODO: pagination and region
Q_strncpy( buf, A2M_SCAN_REQUEST, size );
info = buf + sizeof( A2M_SCAN_REQUEST ) - 1;
remaining = size - sizeof( A2M_SCAN_REQUEST );
char *info = buf + sizeof( A2M_SCAN_REQUEST ) - 1;
size_t remaining = size - sizeof( A2M_SCAN_REQUEST );
Q_strncpy( info, filter, remaining );
@@ -62,6 +59,8 @@ static size_t NET_BuildMasterServerScanRequest( char *buf, size_t size, uint32_t
if( proto != PROTO_GOLDSRC )
{
char temp[32];
// let master know about client version
Info_SetValueForKey( info, "clver", XASH_VERSION, remaining );
Info_SetValueForKey( info, "nat", nat ? "1" : "0", remaining );
@@ -87,15 +86,13 @@ NET_GetMasterHostByName
*/
static net_gai_state_t NET_GetMasterHostByName( master_t *m )
{
net_gai_state_t res;
if( host.realtime > m->resolve_time )
m->adr.type = 0;
if( m->adr.type )
return NET_EAI_OK;
res = NET_StringToAdrNB( m->address, &m->adr, m->v6only );
net_gai_state_t res = NET_StringToAdrNB( m->address, &m->adr, m->v6only );
if( res == NET_EAI_OK )
{
@@ -127,10 +124,9 @@ return true if would block
*/
static qboolean NET_SendToMasters( netsrc_t sock, size_t len, const void *data, connprotocol_t proto )
{
master_t *master;
qboolean wait = false;
for( master = ml.head; master; master = master->next )
for( master_t *master = ml.head; master; master = master->next )
{
if( master->gs )
{
@@ -199,9 +195,7 @@ NET_AnnounceToMaster
*/
void NET_MasterClear( void )
{
master_t *m;
for( m = ml.head; m; m = m->next )
for( master_t *m = ml.head; m; m = m->next )
m->last_heartbeat = MAX_HEARTBEAT;
}
@@ -213,11 +207,8 @@ NET_MasterQuery
qboolean NET_MasterQuery( uint32_t key, qboolean nat, const char *filter )
{
char buf[512];
size_t len;
qboolean wait = false;
len = NET_BuildMasterServerScanRequest( buf, sizeof( buf ), key, nat, filter, PROTO_CURRENT );
wait = NET_SendToMasters( NS_CLIENT, len, buf, PROTO_CURRENT );
size_t len = NET_BuildMasterServerScanRequest( buf, sizeof( buf ), key, nat, filter, PROTO_CURRENT );
qboolean wait = NET_SendToMasters( NS_CLIENT, len, buf, PROTO_CURRENT );
// goldsrc don't have nat traversal extensions
if( !nat )
@@ -240,12 +231,10 @@ NET_MasterHeartbeat
*/
void NET_MasterHeartbeat( void )
{
master_t *m;
if(( !public_server.value && !sv_nat.value ) || svs.maxclients == 1 )
return; // only public servers send heartbeats
for( m = ml.head; m; m = m->next )
for( master_t *m = ml.head; m; m = m->next )
{
if( host.realtime - m->last_heartbeat < HEARTBEAT_SECONDS )
continue;
@@ -296,9 +285,7 @@ NET_GetMasterFromAdr
*/
static master_t *NET_GetMasterFromAdr( netadr_t adr )
{
master_t *master;
for( master = ml.head; master; master = master->next )
for( master_t *master = ml.head; master; master = master->next )
{
if( NET_CompareAdr( adr, master->adr ))
return master;
@@ -315,9 +302,7 @@ NET_GetMaster
*/
qboolean NET_GetMaster( netadr_t from, uint *challenge, double *last_heartbeat )
{
master_t *m;
m = NET_GetMasterFromAdr( from );
master_t *m = NET_GetMasterFromAdr( from );
if( m )
{
@@ -356,15 +341,13 @@ Add master to the list
*/
static master_t *NET_AddMaster( const char *addr )
{
master_t *master;
for( master = ml.head; master; master = master->next )
for( master_t *master = ml.head; master; master = master->next )
{
if( !Q_stricmp( master->address, addr )) // already exists
return master;
}
master = Mem_Calloc( host.mempool, sizeof( *master ));
master_t *master = Mem_Calloc( host.mempool, sizeof( *master ));
Q_strncpy( master->address, addr, sizeof( master->address ));
if( ml.tail )
@@ -382,15 +365,13 @@ static master_t *NET_AddMaster( const char *addr )
static void NET_AddMaster_f( void )
{
master_t *master;
if( Cmd_Argc() != 2 )
{
Msg( S_USAGE "addmaster <address> [gs]\n");
return;
}
master = NET_AddMaster( Cmd_Argv( 1 ));
master_t *master = NET_AddMaster( Cmd_Argv( 1 ));
master->save = true;
if( !Q_stricmp( Cmd_Argv( 2 ), "gs" ))
@@ -427,12 +408,10 @@ Display current master linked list
*/
static void NET_ListMasters_f( void )
{
master_t *master;
int i;
Con_Printf( "Master servers:\n" );
for( i = 1, master = ml.head; master; i++, master = master->next )
int i = 1;
for( master_t *master = ml.head; master; i++, master = master->next )
{
Con_Printf( "%d\t%s", i, master->address );
if( master->adr.type != 0 )
@@ -457,11 +436,8 @@ Load master server list from xashcomm.lst
*/
static void NET_LoadMasters( void )
{
byte *afile;
char *pfile;
char token[MAX_TOKEN];
afile = FS_LoadFile( "xashcomm.lst", NULL, false );
byte *afile = FS_LoadFile( "xashcomm.lst", NULL, false );
if( !afile ) // file doesn't exist yet
{
@@ -469,7 +445,7 @@ static void NET_LoadMasters( void )
return;
}
pfile = (char*)afile;
char *pfile = (char*)afile;
// format: master <addr>\n
while(( pfile = COM_ParseFile( pfile, token, sizeof( token ))))
@@ -515,13 +491,10 @@ Save master server list to xashcomm.lst, except for default
*/
void NET_SaveMasters( void )
{
file_t *f;
master_t *m;
if( !ml.modified )
return;
f = FS_Open( "xashcomm.lst", "w", true );
file_t *f = FS_Open( "xashcomm.lst", "w", true );
if( !f )
{
@@ -529,7 +502,7 @@ void NET_SaveMasters( void )
return;
}
for( m = ml.head; m; m = m->next )
for( master_t *m = ml.head; m; m = m->next )
{
const char *key;

74
engine/common/mod_alias.c
View File

@@ -27,20 +27,17 @@ static const trivertex_t *g_poseverts[MAXALIASFRAMES];
static const void *Mod_LoadAliasFrame( const daliasframe_t *pdaliasframe, maliasframedesc_t *frame, const aliashdr_t *aliashdr )
{
const trivertex_t *pinframe;
int i;
Q_strncpy( frame->name, pdaliasframe->name, sizeof( frame->name ));
frame->firstpose = g_posenum;
frame->numposes = 1;
for( i = 0; i < 3; i++ )
for( int i = 0; i < 3; i++ )
{
frame->bboxmin.v[i] = pdaliasframe->bboxmin.v[i];
frame->bboxmax.v[i] = pdaliasframe->bboxmax.v[i];
}
pinframe = (const trivertex_t *)(pdaliasframe + 1);
const trivertex_t *pinframe = (const trivertex_t *)(pdaliasframe + 1);
g_poseverts[g_posenum] = pinframe;
g_posenum++;
@@ -52,27 +49,25 @@ static const void *Mod_LoadAliasFrame( const daliasframe_t *pdaliasframe, malias
static const void *Mod_LoadAliasGroup( const daliasgroup_t *pingroup, maliasframedesc_t *frame, const aliashdr_t *aliashdr )
{
const daliasinterval_t *pin_intervals;
const void *ptemp;
int i, numframes;
int numframes;
frame->firstpose = g_posenum;
frame->numposes = numframes = pingroup->numframes;
for( i = 0; i < 3; i++ )
for( int i = 0; i < 3; i++ )
{
frame->bboxmin.v[i] = pingroup->bboxmin.v[i];
frame->bboxmax.v[i] = pingroup->bboxmax.v[i];
}
pin_intervals = (const daliasinterval_t *)(pingroup + 1);
const daliasinterval_t *pin_intervals = (const daliasinterval_t *)(pingroup + 1);
// all the intervals are always equal 0.1 so we don't care about them
frame->interval = pin_intervals->interval;
pin_intervals += numframes;
ptemp = (void *)pin_intervals;
const void *ptemp = (void *)pin_intervals;
for( i = 0; i < numframes; i++ )
for( int i = 0; i < numframes; i++ )
{
g_poseverts[g_posenum] = (const trivertex_t *)((const daliasframe_t *)ptemp + 1);
ptemp = g_poseverts[g_posenum] + aliashdr->numverts;
@@ -84,24 +79,20 @@ static const void *Mod_LoadAliasGroup( const daliasgroup_t *pingroup, maliasfram
static void Mod_CalcAliasBounds( model_t *mod, const aliashdr_t *aliashdr )
{
int i, j, k;
float radius;
float dist;
vec3_t v;
ClearBounds( mod->mins, mod->maxs );
radius = 0.0f;
float radius = 0.0f;
// process verts
for( i = 0; i < aliashdr->numposes; i++ )
for( int i = 0; i < aliashdr->numposes; i++ )
{
for( j = 0; j < aliashdr->numverts; j++ )
for( int j = 0; j < aliashdr->numverts; j++ )
{
for( k = 0; k < 3; k++ )
vec3_t v;
for( int k = 0; k < 3; k++ )
v[k] = g_poseverts[i][j].v[k] * aliashdr->scale[k] + aliashdr->scale_origin[k];
AddPointToBounds( v, mod->mins, mod->maxs );
dist = DotProduct( v, v );
float dist = DotProduct( v, v );
if( radius < dist )
radius = dist;
@@ -113,15 +104,13 @@ static void Mod_CalcAliasBounds( model_t *mod, const aliashdr_t *aliashdr )
static const void *Mod_LoadAllSkins( model_t *mod, int numskins, const daliasskintype_t *pskintype, const aliashdr_t *aliashdr )
{
int i, size;
if(( numskins < 1 ) || ( numskins > MAX_SKINS ))
Host_Error( "%s: Invalid # of skins: %d\n", __func__, numskins );
size = aliashdr->skinwidth * aliashdr->skinheight;
int size = aliashdr->skinwidth * aliashdr->skinheight;
// just skipping textures, renderer will take care of them later
for( i = 0; i < numskins; i++ )
for( int i = 0; i < numskins; i++ )
{
if( pskintype->type == ALIAS_SKIN_SINGLE )
{
@@ -152,33 +141,24 @@ load alias model
*/
void Mod_LoadAliasModel( model_t *mod, const void *buffer, qboolean *loaded )
{
const daliasframetype_t *pframetype;
const daliasskintype_t *pskintype;
const dtriangle_t *pintriangles;
const daliashdr_t *pinmodel;
const stvert_t *pinstverts;
aliashdr_t *m_pAliasHeader;
size_t size;
char poolname[MAX_VA_STRING];
int i;
if( loaded ) *loaded = false;
pinmodel = (const daliashdr_t *)buffer;
i = pinmodel->version;
const daliashdr_t *pinmodel = (const daliashdr_t *)buffer;
if( i != ALIAS_VERSION )
if( pinmodel->version != ALIAS_VERSION )
{
Con_DPrintf( S_ERROR "%s has wrong version number (%i should be %i)\n", mod->name, i, ALIAS_VERSION );
Con_DPrintf( S_ERROR "%s has wrong version number (%i should be %i)\n", mod->name, pinmodel->version, ALIAS_VERSION );
return;
}
if( pinmodel->numverts <= 0 || pinmodel->numtris <= 0 || pinmodel->numframes <= 0 )
return; // how is it possible to make that?
char poolname[MAX_VA_STRING];
Q_snprintf( poolname, sizeof( poolname ), "^2%s^7", mod->name );
mod->mempool = Mem_AllocPool( poolname );
size = sizeof( aliashdr_t ) + (pinmodel->numframes - 1) * sizeof( maliasframedesc_t );
size_t size = sizeof( aliashdr_t ) + (pinmodel->numframes - 1) * sizeof( maliasframedesc_t );
aliashdr_t *m_pAliasHeader;
mod->cache.data = m_pAliasHeader = Mem_Calloc( mod->mempool, size );
// endian-adjust and copy the data, starting with the alias model header
@@ -199,7 +179,7 @@ void Mod_LoadAliasModel( model_t *mod, const void *buffer, qboolean *loaded )
mod->numframes = m_pAliasHeader->numframes = pinmodel->numframes;
m_pAliasHeader->size = pinmodel->size;
for( i = 0; i < 3; i++ )
for( int i = 0; i < 3; i++ )
{
m_pAliasHeader->scale[i] = pinmodel->scale[i];
m_pAliasHeader->scale_origin[i] = pinmodel->scale_origin[i];
@@ -207,24 +187,24 @@ void Mod_LoadAliasModel( model_t *mod, const void *buffer, qboolean *loaded )
}
// load the skins
pskintype = (const daliasskintype_t *)&pinmodel[1];
const daliasskintype_t *pskintype = (const daliasskintype_t *)&pinmodel[1];
pskintype = Mod_LoadAllSkins( mod, m_pAliasHeader->numskins, pskintype, m_pAliasHeader );
// will be done at renderer side...
// load base s and t vertices
pinstverts = (const stvert_t *)pskintype;
const stvert_t *pinstverts = (const stvert_t *)pskintype;
// will be done at renderer side...
// load triangle lists
pintriangles = (const dtriangle_t *)&pinstverts[m_pAliasHeader->numverts];
const dtriangle_t *pintriangles = (const dtriangle_t *)&pinstverts[m_pAliasHeader->numverts];
// will be done at renderer side
// load the frames
pframetype = (const daliasframetype_t *)&pintriangles[m_pAliasHeader->numtris];
const daliasframetype_t *pframetype = (const daliasframetype_t *)&pintriangles[m_pAliasHeader->numtris];
m_pAliasHeader->pposeverts = g_poseverts; // store the pointer to be accessed by renderer
g_posenum = 0;
for( i = 0; i < m_pAliasHeader->numframes; i++ )
for( int i = 0; i < m_pAliasHeader->numframes; i++ )
{
aliasframetype_t frametype = pframetype->type;

498
engine/common/mod_bmodel.c
View File

File diff suppressed because it is too large Load Diff

16
engine/common/mod_sprite.c
View File

@@ -111,14 +111,14 @@ static byte *Mod_SwapSpriteGroup( byte *p, byte *end, int bytes )
static qboolean Mod_SwapSprite( void *buffer, size_t buffersize, int *out_version )
{
byte *end = (byte *)buffer + buffersize;
int version, numframes, bytes;
int numframes;
byte *p;
if( buffersize < sizeof( dsprite_t ))
return false;
// peek at ident + version before full swap
version = LittleLong(((dsprite_t *)buffer)->version );
int version = LittleLong(((dsprite_t *)buffer)->version );
switch( version )
{
@@ -152,7 +152,7 @@ static qboolean Mod_SwapSprite( void *buffer, size_t buffersize, int *out_versio
}
*out_version = version;
bytes = ( version == SPRITE_VERSION_32 ) ? 4 : 1;
int bytes = ( version == SPRITE_VERSION_32 ) ? 4 : 1;
// swap all frames
for( int i = 0; i < numframes && p && p < end; i++ )
@@ -194,12 +194,11 @@ load sprite model
void Mod_LoadSpriteModel( model_t *mod, void *buffer, size_t buffersize, qboolean *loaded )
{
msprite_t *psprite;
char poolname[MAX_VA_STRING];
int version;
if( loaded )
*loaded = false;
int version;
if( !Mod_SwapSprite( buffer, buffersize, &version ))
{
Con_DPrintf( S_ERROR "%s: %s is not a valid sprite\n", __func__, mod->name );
@@ -207,13 +206,13 @@ void Mod_LoadSpriteModel( model_t *mod, void *buffer, size_t buffersize, qboolea
}
mod->type = mod_sprite;
char poolname[MAX_VA_STRING];
Q_snprintf( poolname, sizeof( poolname ), "^2%s^7", mod->name );
mod->mempool = Mem_AllocPool( poolname );
if( version == SPRITE_VERSION_Q1 || version == SPRITE_VERSION_32 )
{
dsprite_q1_t *pinq1 = buffer;
size_t size;
if( pinq1->numframes == 0 )
{
@@ -221,7 +220,7 @@ void Mod_LoadSpriteModel( model_t *mod, void *buffer, size_t buffersize, qboolea
return;
}
size = sizeof( msprite_t ) + ( pinq1->numframes - 1 ) * sizeof( psprite->frames );
size_t size = sizeof( msprite_t ) + ( pinq1->numframes - 1 ) * sizeof( psprite->frames );
psprite = Mem_Calloc( mod->mempool, size );
mod->cache.data = psprite; // make link to extradata
@@ -245,7 +244,6 @@ void Mod_LoadSpriteModel( model_t *mod, void *buffer, size_t buffersize, qboolea
else // if( version == SPRITE_VERSION_HL )
{
dsprite_hl_t *pinhl = buffer;
size_t size;
if( pinhl->numframes == 0 )
{
@@ -253,7 +251,7 @@ void Mod_LoadSpriteModel( model_t *mod, void *buffer, size_t buffersize, qboolea
return;
}
size = sizeof( msprite_t ) + ( pinhl->numframes - 1 ) * sizeof( psprite->frames );
size_t size = sizeof( msprite_t ) + ( pinhl->numframes - 1 ) * sizeof( psprite->frames );
psprite = Mem_Calloc( mod->mempool, size );
mod->cache.data = psprite; // make link to extradata

27
engine/common/mod_studio.c
View File

@@ -211,12 +211,10 @@ Mod_InitStudioHull
*/
void Mod_InitStudioHull( void )
{
int i;
if( studio_hull[0].planes != NULL )
return; // already initailized
for( i = 0; i < MAXSTUDIOBONES; i++ )
for( int i = 0; i < MAXSTUDIOBONES; i++ )
{
studio_hull[i].clipnodes16 = (mclipnode16_t *)box_clipnodes16;
studio_hull[i].planes = &studio_planes[i*6];
@@ -265,13 +263,11 @@ AddToStudioCache
*/
static void Mod_AddToStudioCache( float frame, int sequence, vec3_t angles, vec3_t origin, vec3_t size, byte *pcontroller, byte *pblending, model_t *model, hull_t *hull, int numhitboxes )
{
mstudiocache_t *pCache;
if( numhitboxes + cache_current_hull >= MAXSTUDIOBONES )
Mod_ClearStudioCache();
cache_current++;
pCache = &cache_studio[cache_current & STUDIO_CACHEMASK];
mstudiocache_t *pCache = &cache_studio[cache_current & STUDIO_CACHEMASK];
pCache->frame = frame;
pCache->sequence = sequence;
@@ -302,12 +298,9 @@ CheckStudioCache
*/
static mstudiocache_t *Mod_CheckStudioCache( model_t *model, float frame, int sequence, vec3_t angles, vec3_t origin, vec3_t size, byte *controller, byte *blending )
{
mstudiocache_t *pCached;
int i;
for( i = 0; i < STUDIO_CACHESIZE; i++ )
for( int i = 0; i < STUDIO_CACHESIZE; i++ )
{
pCached = &cache_studio[(cache_current - i) & STUDIO_CACHEMASK];
mstudiocache_t *pCached = &cache_studio[(cache_current - i) & STUDIO_CACHEMASK];
if( pCached->model != model )
continue;
@@ -378,17 +371,13 @@ NOTE: pEdict may be NULL
hull_t *Mod_HullForStudio( model_t *model, float frame, int sequence, vec3_t angles, vec3_t origin, vec3_t size, byte *pcontroller, byte *pblending, int *numhitboxes, edict_t *pEdict )
{
vec3_t angles2;
mstudiocache_t *bonecache;
mstudiobbox_t *phitbox;
qboolean bSkipShield;
int i, j;
qboolean bSkipShield = false;
bSkipShield = false;
*numhitboxes = 0; // assume error
if( mod_studiocache.value )
{
bonecache = Mod_CheckStudioCache( model, frame, sequence, angles, origin, size, pcontroller, pblending );
mstudiocache_t *bonecache = Mod_CheckStudioCache( model, frame, sequence, angles, origin, size, pcontroller, pblending );
if( bonecache != NULL )
{
@@ -410,12 +399,12 @@ hull_t *Mod_HullForStudio( model_t *model, float frame, int sequence, vec3_t ang
angles2[PITCH] = -angles2[PITCH]; // stupid quake bug
pBlendAPI->SV_StudioSetupBones( model, frame, sequence, angles2, origin, pcontroller, pblending, -1, pEdict );
phitbox = (mstudiobbox_t *)((byte *)mod_studiohdr + mod_studiohdr->hitboxindex);
mstudiobbox_t *phitbox = (mstudiobbox_t *)((byte *)mod_studiohdr + mod_studiohdr->hitboxindex);
if( SV_IsValidEdict( pEdict ) && pEdict->v.gamestate == 1 )
bSkipShield = 1;
for( i = j = 0; i < mod_studiohdr->numhitboxes; i++, j += 6 )
for( int i = 0, j = 0; i < mod_studiohdr->numhitboxes; i++, j += 6 )
{
if( world.version == QBSP2_VERSION )
studio_hull[i].clipnodes32 = (mclipnode32_t *)box_clipnodes32;

47
engine/common/model.c
View File

@@ -195,12 +195,10 @@ Mod_FreeAll
*/
void Mod_FreeAll( void )
{
int i;
#if !XASH_DEDICATED
Mod_ReleaseHullPolygons();
#endif
for( i = 0; i < mod_numknown; i++ )
for( int i = 0; i < mod_numknown; i++ )
Mod_FreeModel( &mod_known[i] );
mod_numknown = 0;
}
@@ -212,9 +210,7 @@ Mod_ClearUserData
*/
void Mod_ClearUserData( void )
{
int i;
for( i = 0; i < mod_numknown; i++ )
for( int i = 0; i < mod_numknown; i++ )
Mod_FreeUserData( &mod_known[i] );
}
@@ -301,8 +297,6 @@ model_t *Mod_LoadModel( model_t *mod, qboolean crash )
char tempname[MAX_QPATH];
fs_offset_t length = 0;
qboolean loaded, loaded2 = false;
byte *buf;
model_info_t *p;
if( !mod )
{
@@ -327,7 +321,7 @@ model_t *Mod_LoadModel( model_t *mod, qboolean crash )
Q_strncpy( tempname, mod->name, sizeof( tempname ));
COM_FixSlashes( tempname );
buf = FS_LoadFile( tempname, &length, false );
byte *buf = FS_LoadFile( tempname, &length, false );
if( !buf || length < sizeof( uint ))
{
@@ -407,7 +401,7 @@ model_t *Mod_LoadModel( model_t *mod, qboolean crash )
return NULL;
}
p = &mod_crcinfo[mod - mod_known];
model_info_t *p = &mod_crcinfo[mod - mod_known];
mod->needload = NL_PRESENT;
if( FBitSet( p->flags, FCRC_SHOULD_CHECKSUM ))
@@ -443,12 +437,10 @@ Loads in a model for the given name
*/
model_t *Mod_ForName( const char *name, qboolean crash, qboolean trackCRC )
{
model_t *mod;
if( COM_StringEmptyOrNULL( name ))
return NULL;
mod = Mod_FindName( name, trackCRC );
model_t *mod = Mod_FindName( name, trackCRC );
return Mod_LoadModel( mod, crash );
}
@@ -461,8 +453,6 @@ free studio cache on change level
*/
static void Mod_PurgeStudioCache( void )
{
int i;
// refresh hull data
SetBits( r_showhull.flags, FCVAR_CHANGED );
#if !XASH_DEDICATED
@@ -473,7 +463,7 @@ static void Mod_PurgeStudioCache( void )
// we should release all the world submodels
// and clear studio sequences
for( i = 1; i < mod_numknown; i++ )
for( int i = 1; i < mod_numknown; i++ )
{
if( mod_known[i].needload == NL_UNREFERENCED )
continue;
@@ -500,8 +490,6 @@ Loads in the map and all submodels
*/
model_t *Mod_LoadWorld( const char *name, qboolean preload )
{
model_t *pworld;
// already loaded?
if( !Q_stricmp( mod_known->name, name ))
return mod_known;
@@ -511,7 +499,7 @@ model_t *Mod_LoadWorld( const char *name, qboolean preload )
// load the newmap
world.loading = true;
pworld = Mod_FindName( name, false );
model_t *pworld = Mod_FindName( name, false );
if( preload ) Mod_LoadModel( pworld, true );
world.loading = false;
@@ -555,12 +543,10 @@ Mod_Calloc
*/
void *GAME_EXPORT Mod_Calloc( int number, size_t size )
{
cache_user_t *cu;
if( number <= 0 || size <= 0 )
return NULL;
cu = (cache_user_t *)Mem_Calloc( com_studiocache, sizeof( cache_user_t ) + number * size );
cache_user_t *cu = (cache_user_t *)Mem_Calloc( com_studiocache, sizeof( cache_user_t ) + number * size );
cu->data = (void *)cu; // make sure that cu->data is not NULL
return cu;
@@ -593,7 +579,6 @@ void GAME_EXPORT Mod_LoadCacheFile( const char *filename, cache_user_t *cu )
{
char modname[MAX_QPATH];
fs_offset_t size;
byte *buf;
Assert( cu != NULL );
@@ -603,7 +588,7 @@ void GAME_EXPORT Mod_LoadCacheFile( const char *filename, cache_user_t *cu )
Q_strncpy( modname, filename, sizeof( modname ));
COM_FixSlashes( modname );
buf = FS_LoadFile( modname, &size, false );
byte *buf = FS_LoadFile( modname, &size, false );
if( !buf || !size ) Host_Error( "LoadCacheFile: ^1can't load %s^7\n", filename );
cu->data = Mem_Malloc( com_studiocache, size );
memcpy( cu->data, buf, size );
@@ -643,11 +628,8 @@ Mod_ValidateCRC
*/
qboolean Mod_ValidateCRC( const char *name, uint32_t crc )
{
model_info_t *p;
model_t *mod;
mod = Mod_FindName( name, true );
p = &mod_crcinfo[mod - mod_known];
model_t *mod = Mod_FindName( name, true );
model_info_t *p = &mod_crcinfo[mod - mod_known];
if( !FBitSet( p->flags, FCRC_CHECKSUM_DONE ))
return true;
@@ -664,11 +646,8 @@ Mod_NeedCRC
*/
void Mod_NeedCRC( const char *name, qboolean needCRC )
{
model_t *mod;
model_info_t *p;
mod = Mod_FindName( name, true );
p = &mod_crcinfo[mod - mod_known];
model_t *mod = Mod_FindName( name, true );
model_info_t *p = &mod_crcinfo[mod - mod_known];
if( needCRC ) SetBits( p->flags, FCRC_SHOULD_CHECKSUM );
else ClearBits( p->flags, FCRC_SHOULD_CHECKSUM );

12
engine/common/munge.c
View File

@@ -44,22 +44,19 @@ static uint COM_SwapLong( uint c )
static void COM_GenericMunge( byte *data, const size_t len, const int seq, const byte *table, const qboolean reverse )
{
const size_t mungelen = len / 4;
int i;
for( i = 0; i < mungelen; i++ )
for( int i = 0; i < mungelen; i++ )
{
uint32_t c;
void *pc = &data[i * 4];
byte *p;
int j;
memcpy( &c, pc, sizeof( c ));
c ^= seq;
if( !reverse )
c = COM_SwapLong( c );
p = (byte *)&c;
for( j = 0; j < 4; j++ )
byte *p = (byte *)&c;
for( int j = 0; j < 4; j++ )
*p++ ^= (0xa5 | (j << j) | j | table[(i + j) & 0x0f]);
if( reverse )
@@ -123,11 +120,10 @@ void Test_RunMunge( void )
};
string buf;
size_t msglen = Q_strlen( msg ) + 1;
int i;
Q_strncpy( buf, msg, msglen );
for( i = 0; i < 0xFF; i++ )
for( int i = 0; i < 0xFF; i++ )
{
COM_Munge( buf, msglen, i );
if( i < sizeof( expected ) / sizeof( expected[0] ))

37
engine/common/net_buffer.c
View File

@@ -308,8 +308,6 @@ void MSG_WriteUBitLong( sizebuf_t *sb, uint curData, int numbits )
int nBitsLeft = numbits;
int iCurBit = sb->iCurBit;
uint iDWord = iCurBit >> 5; // Mask in a dword.
uint32_t iCurBitMasked;
int nBitsWritten;
Assert( numbits >= 1 && numbits <= 32 );
@@ -320,14 +318,14 @@ void MSG_WriteUBitLong( sizebuf_t *sb, uint curData, int numbits )
return;
}
iCurBitMasked = iCurBit & 31;
uint32_t iCurBitMasked = iCurBit & 31;
uint32_t dword = LittleLong(((uint32_t *)sb->pData)[iDWord] );
dword &= BitWriteMasks[iCurBitMasked][nBitsLeft-1];
dword |= curData << iCurBitMasked;
((uint32_t *)sb->pData)[iDWord] = LittleLong( dword );
// did it span a dword?
nBitsWritten = 32 - iCurBitMasked;
int nBitsWritten = 32 - iCurBitMasked;
if( nBitsWritten < nBitsLeft )
{
@@ -429,13 +427,12 @@ void MSG_WriteBitAngle( sizebuf_t *sb, float fAngle, int numbits )
{
const uint shift = ( 1 << numbits );
const uint mask = shift - 1;
int d;
// clamp the angle before receiving
fAngle = fmod( fAngle, 360.0f );
if( fAngle < 0 ) fAngle += 360.0f;
d = (int)(( fAngle * shift ) / 360.0f );
int d = (int)(( fAngle * shift ) / 360.0f );
d &= mask;
MSG_WriteUBitLong( sb, (uint)d, numbits );
@@ -546,11 +543,10 @@ qboolean MSG_WriteString( sizebuf_t *sb, const char *pStr )
qboolean MSG_WriteStringf( sizebuf_t *sb, const char *format, ... )
{
va_list va;
int len;
char buf[MAX_VA_STRING];
va_start( va, format );
len = Q_vsnprintf( buf, sizeof( buf ), format, va );
int len = Q_vsnprintf( buf, sizeof( buf ), format, va );
va_end( va );
if( len < 0 )
@@ -577,9 +573,6 @@ int MSG_ReadOneBit( sizebuf_t *sb )
uint MSG_ReadUBitLong( sizebuf_t *sb, int numbits )
{
int idword1;
uint dword1, ret;
if( numbits == 8 )
{
int leftBits = MSG_GetNumBitsLeft( sb );
@@ -597,12 +590,12 @@ uint MSG_ReadUBitLong( sizebuf_t *sb, int numbits )
Assert( numbits > 0 && numbits <= 32 );
// Read the current dword.
idword1 = sb->iCurBit >> 5;
dword1 = LittleLong(((uint *)sb->pData)[idword1] );
int idword1 = sb->iCurBit >> 5;
uint dword1 = LittleLong(((uint *)sb->pData)[idword1] );
dword1 >>= ( sb->iCurBit & 31 ); // get the bits we're interested in.
sb->iCurBit += numbits;
ret = dword1;
uint ret = dword1;
// Does it span this dword?
if(( sb->iCurBit - 1 ) >> 5 == idword1 )
@@ -726,10 +719,10 @@ int MSG_ReadCmd( sizebuf_t *sb, netsrc_t type )
int MSG_ReadChar( sizebuf_t *sb )
{
int alt = sb->iAlternateSign, ret;
int alt = sb->iAlternateSign;
sb->iAlternateSign = 0;
ret = MSG_ReadSBitLong( sb, sizeof( int8_t ) << 3 );
int ret = MSG_ReadSBitLong( sb, sizeof( int8_t ) << 3 );
sb->iAlternateSign = alt;
return ret;
@@ -742,10 +735,10 @@ int MSG_ReadByte( sizebuf_t *sb )
int MSG_ReadShort( sizebuf_t *sb )
{
int alt = sb->iAlternateSign, ret;
int alt = sb->iAlternateSign;
sb->iAlternateSign = 0;
ret = MSG_ReadSBitLong( sb, sizeof( int16_t ) << 3 );
int ret = MSG_ReadSBitLong( sb, sizeof( int16_t ) << 3 );
sb->iAlternateSign = alt;
return ret;
@@ -780,10 +773,10 @@ void MSG_ReadVec3Angles( sizebuf_t *sb, vec3_t fa )
int MSG_ReadLong( sizebuf_t *sb )
{
int alt = sb->iAlternateSign, ret;
int alt = sb->iAlternateSign;
sb->iAlternateSign = 0;
ret = MSG_ReadSBitLong( sb, sizeof( int32_t ) << 3 );
int ret = MSG_ReadSBitLong( sb, sizeof( int32_t ) << 3 );
sb->iAlternateSign = alt;
return ret;
@@ -842,14 +835,14 @@ char *MSG_ReadStringLine( sizebuf_t *sb )
void MSG_ExciseBits( sizebuf_t *sb, int startbit, int bitstoremove )
{
int i, endbit = startbit + bitstoremove;
int endbit = startbit + bitstoremove;
int remaining_to_end = sb->nDataBits - endbit;
sizebuf_t temp;
MSG_StartWriting( &temp, sb->pData, MSG_GetMaxBytes( sb ), startbit, -1 );
MSG_SeekToBit( sb, endbit, SEEK_SET );
for( i = 0; i < remaining_to_end; i++ )
for( int i = 0; i < remaining_to_end; i++ )
{
MSG_WriteOneBit( &temp, MSG_ReadOneBit( sb ));
}

270
engine/common/net_chan.c
View File

@@ -164,10 +164,9 @@ Netchan_Init
void Netchan_Init( void )
{
char buf[32];
int port;
// pick a port value that should be nice and random
port = COM_RandomLong( 1, 65535 );
int port = COM_RandomLong( 1, 65535 );
Q_snprintf( buf, sizeof( buf ), "%i", port );
Cvar_RegisterVariable( &net_showpackets );
@@ -261,9 +260,7 @@ Netchan_IncomingReady
*/
qboolean Netchan_IncomingReady( netchan_t *chan )
{
int i;
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
if( chan->incomingready[i] )
return true;
@@ -299,8 +296,6 @@ Netchan_UnlinkFragment
*/
static void Netchan_UnlinkFragment( fragbuf_t *buf, fragbuf_t **list )
{
fragbuf_t *search;
if( !list ) return;
// at head of list
@@ -314,7 +309,7 @@ static void Netchan_UnlinkFragment( fragbuf_t *buf, fragbuf_t **list )
return;
}
search = *list;
fragbuf_t *search = *list;
while( search->next )
{
if( search->next == buf )
@@ -337,16 +332,14 @@ Netchan_ClearFragbufs
*/
static void Netchan_ClearFragbufs( fragbuf_t **ppbuf )
{
fragbuf_t *buf, *n;
if( !ppbuf ) return;
// Throw away any that are sitting around
buf = *ppbuf;
fragbuf_t *buf = *ppbuf;
while( buf )
{
n = buf->next;
fragbuf_t *n = buf->next;
Mem_Free( buf );
buf = n;
}
@@ -362,16 +355,13 @@ Netchan_ClearFragments
*/
static void Netchan_ClearFragments( netchan_t *chan )
{
fragbufwaiting_t *wait, *next;
int i;
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
wait = chan->waitlist[i];
fragbufwaiting_t *wait = chan->waitlist[i];
while( wait )
{
next = wait->next;
fragbufwaiting_t *next = wait->next;
Netchan_ClearFragbufs( &wait->fragbufs );
Mem_Free( wait );
wait = next;
@@ -391,14 +381,12 @@ Netchan_Clear
*/
void Netchan_Clear( netchan_t *chan )
{
int i;
Netchan_ClearFragments( chan );
chan->cleartime = 0.0;
chan->reliable_length = 0;
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
chan->reliable_fragid[i] = 0;
chan->reliable_fragment[i] = 0;
@@ -453,13 +441,12 @@ void Netchan_OutOfBandPrint( int net_socket, netadr_t adr, const char *fmt, ...
{
va_list va;
byte buf[MAX_PRINT_MSG + 4] = { 0xff, 0xff, 0xff, 0xff };
int len;
if( CL_IsPlaybackDemo( ))
return;
va_start( va, fmt );
len = Q_vsnprintf( &buf[4], sizeof( buf ) - 4, fmt, va );
int len = Q_vsnprintf( &buf[4], sizeof( buf ) - 4, fmt, va );
va_end( va );
if( len < 0 )
@@ -479,9 +466,7 @@ Netchan_AllocFragbuf
*/
static fragbuf_t *Netchan_AllocFragbuf( int fragment_size )
{
fragbuf_t *buf;
buf = (fragbuf_t *)Mem_Calloc( net_mempool, sizeof( fragbuf_t ) + fragment_size );
fragbuf_t *buf = (fragbuf_t *)Mem_Calloc( net_mempool, sizeof( fragbuf_t ) + fragment_size );
MSG_Init( &buf->frag_message, "Frag Message", buf->frag_message_buf, fragment_size );
return buf;
@@ -495,11 +480,9 @@ Netchan_AddFragbufToTail
*/
static void Netchan_AddFragbufToTail( fragbufwaiting_t *wait, fragbuf_t *buf )
{
fragbuf_t *p;
buf->next = NULL;
wait->fragbufcount++;
p = wait->fragbufs;
fragbuf_t *p = wait->fragbufs;
if( p )
{
@@ -519,12 +502,11 @@ Netchan_UpdateFlow
static void Netchan_UpdateFlow( netchan_t *chan )
{
float faccumulatedtime = 0.0;
int i, bytes = 0;
int flow, start;
int bytes = 0;
if( !chan ) return;
for( flow = 0; flow < 2; flow++ )
for( int flow = 0; flow < 2; flow++ )
{
flow_t *pflow = &chan->flow[flow];
@@ -532,10 +514,10 @@ static void Netchan_UpdateFlow( netchan_t *chan )
continue;
pflow->nextcompute = host.realtime + FLOW_INTERVAL;
start = pflow->current - 1;
int start = pflow->current - 1;
// compute data flow rate
for( i = 0; i < MASK_LATENT; i++ )
for( int i = 0; i < MASK_LATENT; i++ )
{
flowstats_t *pprev = &pflow->stats[(start - i) & MASK_LATENT];
flowstats_t *pstat = &pflow->stats[(start - i - 1) & MASK_LATENT];
@@ -558,17 +540,14 @@ Fragmentation buffer is full and user is prepared to send
*/
void Netchan_FragSend( netchan_t *chan )
{
fragbufwaiting_t *wait;
int i;
if( !chan ) return;
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
// already something queued up, just leave in waitlist
if( chan->fragbufs[i] ) continue;
wait = chan->waitlist[i];
fragbufwaiting_t *wait = chan->waitlist[i];
// nothing to queue?
if( !wait ) continue;
@@ -594,10 +573,6 @@ Netchan_AddBufferToList
*/
void Netchan_AddBufferToList( fragbuf_t **pplist, fragbuf_t *pbuf )
{
// Find best slot
fragbuf_t *pprev, *n;
int id1, id2;
pbuf->next = NULL;
if( !pplist )
@@ -610,12 +585,13 @@ void Netchan_AddBufferToList( fragbuf_t **pplist, fragbuf_t *pbuf )
return;
}
pprev = *pplist;
// Find best slot
fragbuf_t *pprev = *pplist;
while( pprev->next )
{
n = pprev->next; // next item in list
id1 = FRAG_GETID( n->bufferid );
id2 = FRAG_GETID( pbuf->bufferid );
fragbuf_t *n = pprev->next; // next item in list
int id1 = FRAG_GETID( n->bufferid );
int id2 = FRAG_GETID( pbuf->bufferid );
if( id1 > id2 )
{
@@ -642,19 +618,14 @@ Netchan_CreateFragments_
*/
static void Netchan_CreateFragments_( netchan_t *chan, sizebuf_t *msg )
{
fragbuf_t *buf;
int chunksize;
int remaining;
int bytes, pos;
int bufferid = 1;
fragbufwaiting_t *wait, *p;
if( MSG_GetNumBytesWritten( msg ) == 0 )
return;
chunksize = chan->pfnBlockSize( chan->client, FRAGSIZE_FRAG );
int chunksize = chan->pfnBlockSize( chan->client, FRAGSIZE_FRAG );
wait = (fragbufwaiting_t *)Mem_Calloc( net_mempool, sizeof( fragbufwaiting_t ));
fragbufwaiting_t *wait = (fragbufwaiting_t *)Mem_Calloc( net_mempool, sizeof( fragbufwaiting_t ));
if( chan->use_bz2 && memcmp( MSG_GetData( msg ), "BZ2", 4 ))
{
@@ -691,15 +662,15 @@ static void Netchan_CreateFragments_( netchan_t *chan, sizebuf_t *msg )
if( pbOut ) free( pbOut );
}
remaining = MSG_GetNumBytesWritten( msg );
pos = 0; // current position in bytes
int remaining = MSG_GetNumBytesWritten( msg );
int pos = 0; // current position in bytes
while( remaining > 0 )
{
bytes = Q_min( remaining, chunksize );
int bytes = Q_min( remaining, chunksize );
remaining -= bytes;
buf = Netchan_AllocFragbuf( bytes );
fragbuf_t *buf = Netchan_AllocFragbuf( bytes );
buf->bufferid = bufferid++;
// Copy in data
@@ -717,7 +688,7 @@ static void Netchan_CreateFragments_( netchan_t *chan, sizebuf_t *msg )
}
else
{
p = chan->waitlist[FRAG_NORMAL_STREAM];
fragbufwaiting_t *p = chan->waitlist[FRAG_NORMAL_STREAM];
while( p->next )
p = p->next;
@@ -752,7 +723,6 @@ Netchan_FindBufferById
static fragbuf_t *Netchan_FindBufferById( fragbuf_t **pplist, int id, qboolean allocate )
{
fragbuf_t *list = *pplist;
fragbuf_t *pnewbuf;
int count = 0;
while( list )
@@ -774,7 +744,7 @@ static fragbuf_t *Netchan_FindBufferById( fragbuf_t **pplist, int id, qboolean a
}
// create new entry
pnewbuf = Netchan_AllocFragbuf( NET_MAX_FRAGMENT );
fragbuf_t *pnewbuf = Netchan_AllocFragbuf( NET_MAX_FRAGMENT );
pnewbuf->bufferid = id;
Netchan_AddBufferToList( pplist, pnewbuf );
@@ -789,14 +759,10 @@ Netchan_CheckForCompletion
*/
static void Netchan_CheckForCompletion( netchan_t *chan, int stream, int intotalbuffers )
{
int c, id;
int size;
fragbuf_t *p;
int size = 0;
int c = 0;
size = 0;
c = 0;
p = chan->incomingbufs[stream];
fragbuf_t *p = chan->incomingbufs[stream];
if( !p ) return;
while( p )
@@ -804,7 +770,7 @@ static void Netchan_CheckForCompletion( netchan_t *chan, int stream, int intotal
size += MSG_GetNumBytesWritten( &p->frag_message );
c++;
id = FRAG_GETID( p->bufferid );
int id = FRAG_GETID( p->bufferid );
if( id != c )
{
if( chan->sock == NS_CLIENT )
@@ -829,20 +795,15 @@ Netchan_CreateFileFragmentsFromBuffer
*/
void Netchan_CreateFileFragmentsFromBuffer( netchan_t *chan, const char *filename, byte *pbuf, int size )
{
int chunksize;
int send, pos;
int remaining;
int bufferid = 1;
qboolean firstfragment = true;
fragbufwaiting_t *wait, *p;
fragbuf_t *buf;
uint originalSize = size;
const char *compressor = "";
if( !size )
return;
chunksize = chan->pfnBlockSize( chan->client, FRAGSIZE_FRAG );
int chunksize = chan->pfnBlockSize( chan->client, FRAGSIZE_FRAG );
if( chan->gs_netchan )
{
@@ -876,15 +837,15 @@ void Netchan_CreateFileFragmentsFromBuffer( netchan_t *chan, const char *filenam
free( pbOut );
}
wait = (fragbufwaiting_t *)Mem_Calloc( net_mempool, sizeof( fragbufwaiting_t ));
remaining = size;
pos = 0;
fragbufwaiting_t *wait = (fragbufwaiting_t *)Mem_Calloc( net_mempool, sizeof( fragbufwaiting_t ));
int remaining = size;
int pos = 0;
while( remaining > 0 )
{
send = Q_min( remaining, chunksize );
int send = Q_min( remaining, chunksize );
buf = Netchan_AllocFragbuf( send );
fragbuf_t *buf = Netchan_AllocFragbuf( send );
buf->bufferid = bufferid++;
// copy in data
@@ -894,7 +855,7 @@ void Netchan_CreateFileFragmentsFromBuffer( netchan_t *chan, const char *filenam
{
// write filename
MSG_WriteString( &buf->frag_message, filename );
// write compressor name and uncompressed size
if( chan->gs_netchan )
{
@@ -928,7 +889,7 @@ void Netchan_CreateFileFragmentsFromBuffer( netchan_t *chan, const char *filenam
}
else
{
p = chan->waitlist[FRAG_FILE_STREAM];
fragbufwaiting_t *p = chan->waitlist[FRAG_FILE_STREAM];
while( p->next )
p = p->next;
@@ -944,17 +905,9 @@ Netchan_CreateFileFragments
*/
int Netchan_CreateFileFragments( netchan_t *chan, const char *filename )
{
int chunksize;
int send, pos;
int remaining;
int bufferid = 1;
fs_offset_t filesize = 0;
fs_offset_t originalSize = 0;
int compressedFileTime;
int fileTime;
qboolean firstfragment = true;
qboolean bCompressed = false;
fragbufwaiting_t *wait, *p;
fragbuf_t *buf;
char compressedfilename[sizeof( buf->filename ) + 5];
const char *compressor = "";
@@ -969,18 +922,20 @@ int Netchan_CreateFileFragments( netchan_t *chan, const char *filename )
return 0;
}
if(( filesize = FS_FileSize( filename, false )) <= 0 )
fs_offset_t filesize = FS_FileSize( filename, false );
if( filesize <= 0 )
{
Con_Printf( S_WARN "Unable to open %s for transfer\n", filename );
return 0;
}
originalSize = filesize;
chunksize = chan->pfnBlockSize( chan->client, FRAGSIZE_FRAG );
fs_offset_t originalSize = filesize;
int chunksize = chan->pfnBlockSize( chan->client, FRAGSIZE_FRAG );
Q_snprintf( compressedfilename, sizeof( compressedfilename ), "%s.ztmp", filename );
compressedFileTime = FS_FileTime( compressedfilename, false );
fileTime = FS_FileTime( filename, false );
int compressedFileTime = FS_FileTime( compressedfilename, false );
int fileTime = FS_FileTime( filename, false );
if( compressedFileTime >= fileTime )
{
@@ -1029,13 +984,13 @@ int Netchan_CreateFileFragments( netchan_t *chan, const char *filename )
Mem_Free( uncompressed );
}
wait = (fragbufwaiting_t *)Mem_Calloc( net_mempool, sizeof( fragbufwaiting_t ));
remaining = filesize;
pos = 0;
fragbufwaiting_t *wait = (fragbufwaiting_t *)Mem_Calloc( net_mempool, sizeof( fragbufwaiting_t ));
int remaining = filesize;
int pos = 0;
while( remaining > 0 )
{
send = Q_min( remaining, chunksize );
int send = Q_min( remaining, chunksize );
buf = Netchan_AllocFragbuf( send );
buf->bufferid = bufferid++;
@@ -1080,7 +1035,7 @@ int Netchan_CreateFileFragments( netchan_t *chan, const char *filename )
}
else
{
p = chan->waitlist[FRAG_FILE_STREAM];
fragbufwaiting_t *p = chan->waitlist[FRAG_FILE_STREAM];
while( p->next )
p = p->next;
p->next = wait;
@@ -1097,15 +1052,13 @@ Netchan_FlushIncoming
*/
void Netchan_FlushIncoming( netchan_t *chan, int stream )
{
fragbuf_t *p, *n;
MSG_Clear( &net_message );
p = chan->incomingbufs[ stream ];
fragbuf_t *p = chan->incomingbufs[ stream ];
while( p )
{
n = p->next;
fragbuf_t *n = p->next;
Mem_Free( p );
p = n;
}
@@ -1122,7 +1075,6 @@ Netchan_CopyNormalFragments
qboolean Netchan_CopyNormalFragments( netchan_t *chan, sizebuf_t *msg, size_t *length )
{
size_t size = 0;
fragbuf_t *p, *n;
if( !chan->incomingready[FRAG_NORMAL_STREAM] )
return false;
@@ -1133,13 +1085,13 @@ qboolean Netchan_CopyNormalFragments( netchan_t *chan, sizebuf_t *msg, size_t *l
return false;
}
p = chan->incomingbufs[FRAG_NORMAL_STREAM];
fragbuf_t *p = chan->incomingbufs[FRAG_NORMAL_STREAM];
MSG_Init( msg, "NetMessage", net_message_buffer, sizeof( net_message_buffer ));
while( p )
{
n = p->next;
fragbuf_t *n = p->next;
// copy it in
MSG_WriteBytes( msg, MSG_GetData( &p->frag_message ), MSG_GetNumBytesWritten( &p->frag_message ));
@@ -1209,9 +1161,6 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
{
char filename[MAX_OSPATH], compressor[32];
uint uncompressedSize;
int nsize, pos;
byte *buffer;
fragbuf_t *p, *n;
if( !chan->incomingready[FRAG_FILE_STREAM] )
return false;
@@ -1222,7 +1171,7 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
return false;
}
p = chan->incomingbufs[FRAG_FILE_STREAM];
fragbuf_t *p = chan->incomingbufs[FRAG_FILE_STREAM];
MSG_Init( msg, "NetMessage", net_message_buffer, sizeof( net_message_buffer ));
@@ -1272,7 +1221,7 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
}
// create file from buffers
nsize = 0;
int nsize = 0;
while ( p )
{
nsize += MSG_GetNumBytesWritten( &p->frag_message ); // Size will include a bit of slop, oh well
@@ -1281,17 +1230,15 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
p = p->next;
}
buffer = Mem_Calloc( net_mempool, nsize + 1 );
byte *buffer = Mem_Calloc( net_mempool, nsize + 1 );
p = chan->incomingbufs[FRAG_FILE_STREAM];
pos = 0;
int pos = 0;
while( p )
{
int cursize;
fragbuf_t *n = p->next;
n = p->next;
cursize = MSG_GetNumBytesWritten( &p->frag_message );
int cursize = MSG_GetNumBytesWritten( &p->frag_message );
// first message has the file name, don't write that into the data stream,
// just write the rest of the actual data
@@ -1314,8 +1261,6 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
if( chan->gs_netchan && chan->use_bz2 && !Q_stricmp( compressor, "bz2" ))
{
#if !XASH_DEDICATED
byte *uncompressedBuffer;
if( uncompressedSize == 0 || uncompressedSize > MAX_NETCHAN_DECOMPRESSED_SIZE )
{
Con_Printf( S_ERROR "BZ2 fragment uncompressed size out of range: %u for %s\n", uncompressedSize, filename );
@@ -1324,7 +1269,7 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
return false;
}
uncompressedBuffer = Mem_Calloc( net_mempool, uncompressedSize );
byte *uncompressedBuffer = Mem_Calloc( net_mempool, uncompressedSize );
Con_DPrintf( "Decompressing file %s (%d -> %d bytes)\n", filename, nsize, uncompressedSize );
if( BZ2_bzBuffToBuffDecompress( uncompressedBuffer, &uncompressedSize, buffer, nsize, 1, 0 ) != BZ_OK )
@@ -1344,8 +1289,6 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
}
else if( chan->use_lzss && LZSS_IsCompressed( buffer, nsize ))
{
byte *uncompressedBuffer;
uncompressedSize = LZSS_GetActualSize( buffer, nsize );
if( uncompressedSize == 0 || uncompressedSize > MAX_NETCHAN_DECOMPRESSED_SIZE )
@@ -1356,7 +1299,7 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
return false;
}
uncompressedBuffer = Mem_Calloc( net_mempool, uncompressedSize );
byte *uncompressedBuffer = Mem_Calloc( net_mempool, uncompressedSize );
nsize = LZSS_Decompress( buffer, uncompressedBuffer, nsize, uncompressedSize );
Mem_Free( buffer );
@@ -1390,18 +1333,15 @@ qboolean Netchan_CopyFileFragments( netchan_t *chan, sizebuf_t *msg )
static qboolean Netchan_Validate( netchan_t *chan, sizebuf_t *sb, qboolean *frag_message, uint *fragid, int *frag_offset, int *frag_length )
{
int i, buffer, offset;
int count, length;
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
if( !frag_message[i] )
continue;
buffer = FRAG_GETID( fragid[i] );
count = FRAG_GETCOUNT( fragid[i] );
offset = BitByte( frag_offset[i] );
length = BitByte( frag_length[i] );
int buffer = FRAG_GETID( fragid[i] );
int count = FRAG_GETCOUNT( fragid[i] );
int offset = BitByte( frag_offset[i] );
int length = BitByte( frag_length[i] );
if( buffer < 0 || buffer > NET_MAX_BUFFER_ID )
return false;
@@ -1428,8 +1368,7 @@ Netchan_UpdateProgress
void Netchan_UpdateProgress( netchan_t *chan )
{
#if !XASH_DEDICATED
fragbuf_t *p;
int i, c = 0;
int c = 0;
int total = 0;
float bestpercent = 0.0;
@@ -1443,12 +1382,12 @@ void Netchan_UpdateProgress( netchan_t *chan )
if( !chan->incomingbufs[FRAG_FILE_STREAM] )
return;
for( i = MAX_STREAMS - 1; i >= 0; i-- )
for( int i = MAX_STREAMS - 1; i >= 0; i-- )
{
// receiving data
if( chan->incomingbufs[i] )
{
p = chan->incomingbufs[i];
fragbuf_t *p = chan->incomingbufs[i];
total = FRAG_GETCOUNT( p->bufferid );
@@ -1471,11 +1410,10 @@ void Netchan_UpdateProgress( netchan_t *chan )
if( i == FRAG_FILE_STREAM )
{
char sz[MAX_SYSPATH];
char *in, *out;
int len = 0;
in = (char *)MSG_GetData( &p->frag_message );
out = sz;
char *in = (char *)MSG_GetData( &p->frag_message );
char *out = sz;
while( *in )
{
@@ -1521,10 +1459,9 @@ void Netchan_TransmitBits( netchan_t *chan, int length, const byte *data )
{
byte send_buf[NET_MAX_MESSAGE];
qboolean send_reliable_fragment;
uint w1, w2, statId;
qboolean send_reliable;
sizebuf_t send;
int i, j;
int i;
float fRate;
// check for message overflow
@@ -1686,7 +1623,7 @@ void Netchan_TransmitBits( netchan_t *chan, int length, const byte *data )
chan->reliable_fragment[i] = 1;
// offset the rest of the starting positions
for( j = i + 1; j < MAX_STREAMS; j++ )
for( int j = i + 1; j < MAX_STREAMS; j++ )
chan->frag_startpos[j] += chan->frag_length[i];
}
}
@@ -1696,8 +1633,8 @@ void Netchan_TransmitBits( netchan_t *chan, int length, const byte *data )
MSG_Init( &send, "NetSend", send_buf, sizeof( send_buf ));
// prepare the packet header
w1 = chan->outgoing_sequence | (((uint)send_reliable ) << 31);
w2 = chan->incoming_sequence | (chan->incoming_reliable_sequence << 31);
uint w1 = chan->outgoing_sequence | (((uint)send_reliable ) << 31);
uint w2 = chan->incoming_sequence | (chan->incoming_reliable_sequence << 31);
send_reliable_fragment = false;
@@ -1780,7 +1717,7 @@ void Netchan_TransmitBits( netchan_t *chan, int length, const byte *data )
}
}
statId = chan->flow[FLOW_OUTGOING].current & MASK_LATENT;
uint statId = chan->flow[FLOW_OUTGOING].current & MASK_LATENT;
chan->flow[FLOW_OUTGOING].stats[statId].size = MSG_GetNumBytesWritten( &send ) + UDP_HEADER_SIZE;
chan->flow[FLOW_OUTGOING].stats[statId].time = host.realtime;
chan->flow[FLOW_OUTGOING].totalbytes += chan->flow[FLOW_OUTGOING].stats[statId].size;
@@ -1832,19 +1769,15 @@ modifies net_message so that it points to the packet payload
*/
qboolean Netchan_Process( netchan_t *chan, sizebuf_t *msg )
{
uint sequence, sequence_ack;
uint reliable_ack, reliable_message;
uint fragid[MAX_STREAMS] = { 0, 0 };
qboolean frag_message[MAX_STREAMS] = { false, false };
int frag_offset[MAX_STREAMS] = { 0, 0 };
int frag_length[MAX_STREAMS] = { 0, 0 };
qboolean message_contains_fragments;
int i, statId;
// get sequence numbers
MSG_Clear( msg );
sequence = MSG_ReadLong( msg );
sequence_ack = MSG_ReadLong( msg );
uint sequence = MSG_ReadLong( msg );
uint sequence_ack = MSG_ReadLong( msg );
if( chan->use_munge )
COM_UnMunge2( msg->pData + 8, ( msg->nDataBits >> 3 ) - 8, sequence & 0xFF );
@@ -1853,14 +1786,14 @@ qboolean Netchan_Process( netchan_t *chan, sizebuf_t *msg )
if( chan->sock == NS_SERVER )
MSG_ReadShort( msg );
reliable_message = sequence >> 31;
reliable_ack = sequence_ack >> 31;
uint reliable_message = sequence >> 31;
uint reliable_ack = sequence_ack >> 31;
message_contains_fragments = FBitSet( sequence, BIT( 30 )) ? true : false;
qboolean message_contains_fragments = FBitSet( sequence, BIT( 30 )) ? true : false;
if( message_contains_fragments )
{
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
if( MSG_ReadByte( msg ))
{
@@ -1941,7 +1874,7 @@ qboolean Netchan_Process( netchan_t *chan, sizebuf_t *msg )
chan->last_received = host.realtime;
// Update data flow stats
statId = chan->flow[FLOW_INCOMING].current & MASK_LATENT;
uint statId = chan->flow[FLOW_INCOMING].current & MASK_LATENT;
chan->flow[FLOW_INCOMING].stats[statId].size = MSG_GetMaxBytes( msg ) + UDP_HEADER_SIZE;
chan->flow[FLOW_INCOMING].stats[statId].time = host.realtime;
chan->flow[FLOW_INCOMING].totalbytes += chan->flow[FLOW_INCOMING].stats[statId].size;
@@ -1953,31 +1886,24 @@ qboolean Netchan_Process( netchan_t *chan, sizebuf_t *msg )
if( message_contains_fragments )
{
for( i = 0; i < MAX_STREAMS; i++ )
for( int i = 0; i < MAX_STREAMS; i++ )
{
int j;
int intotalbuffers;
int oldpos, curbit;
int numbitstoremove;
fragbuf_t *pbuf;
if( !frag_message[i] )
continue;
intotalbuffers = FRAG_GETCOUNT( fragid[i] );
int intotalbuffers = FRAG_GETCOUNT( fragid[i] );
if( fragid[i] != 0 )
{
pbuf = Netchan_FindBufferById( &chan->incomingbufs[i], fragid[i], true );
fragbuf_t *pbuf = Netchan_FindBufferById( &chan->incomingbufs[i], fragid[i], true );
if( pbuf )
{
byte buffer[NET_MAX_FRAGMENT];
int bits, size;
sizebuf_t temp;
size = MSG_GetNumBitsRead( msg ) + frag_offset[i];
bits = frag_length[i];
int size = MSG_GetNumBitsRead( msg ) + frag_offset[i];
int bits = frag_length[i];
// copy in data
MSG_Clear( &pbuf->frag_message );
@@ -1992,14 +1918,14 @@ qboolean Netchan_Process( netchan_t *chan, sizebuf_t *msg )
}
// rearrange incoming data to not have the frag stuff in the middle of it
oldpos = MSG_GetNumBitsRead( msg );
curbit = MSG_GetNumBitsRead( msg ) + frag_offset[i];
numbitstoremove = frag_length[i];
int oldpos = MSG_GetNumBitsRead( msg );
int curbit = MSG_GetNumBitsRead( msg ) + frag_offset[i];
int numbitstoremove = frag_length[i];
MSG_ExciseBits( msg, curbit, numbitstoremove );
MSG_SeekToBit( msg, oldpos, SEEK_SET );
for( j = i + 1; j < MAX_STREAMS; j++ )
for( int j = i + 1; j < MAX_STREAMS; j++ )
frag_offset[j] -= frag_length[i];
}

297
engine/common/net_encode.c
View File

@@ -436,12 +436,10 @@ static const delta_info_t dt_goldsrc_meta =
static delta_info_t *Delta_FindStruct( const char *name )
{
int i;
if( COM_StringEmptyOrNULL( name ))
return NULL;
for( i = 0; i < ARRAYSIZE( dt_info ); i++ )
for( int i = 0; i < ARRAYSIZE( dt_info ); i++ )
{
if( !Q_stricmp( dt_info[i].pName, name ))
return &dt_info[i];
@@ -467,12 +465,10 @@ static delta_info_t *Delta_FindStructByIndex( int index )
static delta_info_t *Delta_FindStructByEncoder( const char *encoderName )
{
int i;
if( COM_StringEmptyOrNULL( encoderName ) )
return NULL;
for( i = 0; i < ARRAYSIZE( dt_info ); i++ )
for( int i = 0; i < ARRAYSIZE( dt_info ); i++ )
{
if( !Q_stricmp( dt_info[i].funcName, encoderName ))
return &dt_info[i];
@@ -483,11 +479,9 @@ static delta_info_t *Delta_FindStructByEncoder( const char *encoderName )
static delta_info_t *Delta_FindStructByDelta( const delta_t *pFields )
{
int i;
if( !pFields ) return NULL;
for( i = 0; i < ARRAYSIZE( dt_info ); i++ )
for( int i = 0; i < ARRAYSIZE( dt_info ); i++ )
{
if( dt_info[i].pFields == pFields )
return &dt_info[i];
@@ -498,12 +492,10 @@ static delta_info_t *Delta_FindStructByDelta( const delta_t *pFields )
static void Delta_CustomEncode( delta_info_t *dt, const void *from, const void *to )
{
int i;
Assert( dt != NULL );
// set all fields is active by default
for( i = 0; i < dt->numFields; i++ )
for( int i = 0; i < dt->numFields; i++ )
dt->pFields[i].bInactive = false;
if( dt->userCallback )
@@ -512,12 +504,10 @@ static void Delta_CustomEncode( delta_info_t *dt, const void *from, const void *
static const delta_field_t *Delta_FindFieldInfo( const delta_field_t *pInfo, const char *fieldName, int maxFields )
{
int i;
if( !fieldName || !*fieldName )
return NULL;
for( i = 0; i < maxFields; i++ )
for( int i = 0; i < maxFields; i++ )
{
if( !Q_strcmp( pInfo[i].name, fieldName ))
return &pInfo[i];
@@ -528,12 +518,10 @@ static const delta_field_t *Delta_FindFieldInfo( const delta_field_t *pInfo, con
static int Delta_IndexForFieldInfo( const delta_field_t *pInfo, const char *fieldName, int maxFields )
{
int i;
if( !fieldName || !*fieldName )
return -1;
for( i = 0; i < maxFields; i++ )
for( int i = 0; i < maxFields; i++ )
{
if( !Q_strcmp( pInfo[i].name, fieldName ))
return i;
@@ -543,9 +531,8 @@ static int Delta_IndexForFieldInfo( const delta_field_t *pInfo, const char *fiel
static qboolean Delta_AddField( delta_info_t *dt, const char *pName, int flags, int bits, float mul, float post_mul )
{
const delta_field_t *pFieldInfo;
delta_t *pField;
int i;
delta_t *pField;
int i;
// check for coexisting field
for( i = 0, pField = dt->pFields; i < dt->numFields && pField; i++, pField++ )
@@ -562,7 +549,7 @@ static qboolean Delta_AddField( delta_info_t *dt, const char *pName, int flags,
}
// find field description
pFieldInfo = Delta_FindFieldInfo( dt->pInfo, pName, dt->maxFields );
const delta_field_t *pFieldInfo = Delta_FindFieldInfo( dt->pInfo, pName, dt->maxFields );
if( !pFieldInfo )
{
Con_DPrintf( S_ERROR "%s: couldn't find description for %s->%s\n", __func__, dt->pName, pName );
@@ -594,18 +581,15 @@ static qboolean Delta_AddField( delta_info_t *dt, const char *pName, int flags,
static void Delta_WriteTableField( sizebuf_t *msg, int tableIndex, const delta_t *pField )
{
int nameIndex;
delta_info_t *dt;
Assert( pField != NULL );
if( COM_StringEmptyOrNULL( pField->name ))
return;// not initialized ?
dt = Delta_FindStructByIndex( tableIndex );
delta_info_t *dt = Delta_FindStructByIndex( tableIndex );
Assert( dt && dt->bInitialized );
nameIndex = Delta_IndexForFieldInfo( dt->pInfo, pField->name, dt->maxFields );
int nameIndex = Delta_IndexForFieldInfo( dt->pInfo, pField->name, dt->maxFields );
Assert( nameIndex >= 0 && nameIndex < dt->maxFields );
MSG_BeginServerCmd( msg, svc_deltatable );
@@ -632,19 +616,16 @@ static void Delta_WriteTableField( sizebuf_t *msg, int tableIndex, const delta_t
void Delta_ParseTableField( sizebuf_t *msg )
{
int tableIndex, nameIndex;
float mul = 1.0f, post_mul = 1.0f;
int flags, bits;
const char *pName;
float mul = 1.0f, post_mul = 1.0f;
const char *pName;
qboolean ignore = false;
delta_info_t *dt;
tableIndex = MSG_ReadUBitLong( msg, 4 );
dt = Delta_FindStructByIndex( tableIndex );
int tableIndex = MSG_ReadUBitLong( msg, 4 );
delta_info_t *dt = Delta_FindStructByIndex( tableIndex );
if( !dt )
Host_Error( "%s: not initialized", __func__ );
nameIndex = MSG_ReadUBitLong( msg, 8 ); // read field name index
int nameIndex = MSG_ReadUBitLong( msg, 8 ); // read field name index
if( ( nameIndex >= 0 && nameIndex < dt->maxFields ) )
{
pName = dt->pInfo[nameIndex].name;
@@ -655,8 +636,8 @@ void Delta_ParseTableField( sizebuf_t *msg )
Con_Reportf( "%s: wrong nameIndex %d for table %s, ignoring\n", __func__, nameIndex, dt->pName );
}
flags = MSG_ReadUBitLong( msg, 10 );
bits = MSG_ReadUBitLong( msg, 5 ) + 1;
int flags = MSG_ReadUBitLong( msg, 10 );
int bits = MSG_ReadUBitLong( msg, 5 ) + 1;
// read the multipliers
if( MSG_ReadOneBit( msg ))
@@ -678,9 +659,7 @@ void Delta_ParseTableField( sizebuf_t *msg )
static qboolean Delta_ParseField( char **delta_script, const delta_info_t *dt, delta_t *pField, qboolean bPost )
{
const delta_field_t *pFieldInfo;
string token;
char *oldpos;
string token;
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( Q_strcmp( token, "(" ))
@@ -696,7 +675,7 @@ static qboolean Delta_ParseField( char **delta_script, const delta_info_t *dt, d
return false;
}
pFieldInfo = Delta_FindFieldInfo( dt->pInfo, token, dt->maxFields );
const delta_field_t *pFieldInfo = Delta_FindFieldInfo( dt->pInfo, token, dt->maxFields );
if( !pFieldInfo )
{
Con_DPrintf( S_ERROR "%s: unable to find field %s\n", __func__, token );
@@ -809,7 +788,7 @@ static qboolean Delta_ParseField( char **delta_script, const delta_info_t *dt, d
}
// ... and trying to parse optional ',' post-symbol
oldpos = *delta_script;
char *oldpos = *delta_script;
*delta_script = COM_ParseFile( *delta_script, token, sizeof( token ));
if( token[0] != ',' ) *delta_script = oldpos; // not a ','
@@ -818,13 +797,12 @@ static qboolean Delta_ParseField( char **delta_script, const delta_info_t *dt, d
static void Delta_ParseTable( char **delta_script, delta_info_t *dt, const char *encodeDll, const char *encodeFunc )
{
string token;
delta_t *pField;
string token;
// allocate the delta-structures
if( !dt->pFields ) dt->pFields = (delta_t *)Z_Calloc( dt->maxFields * sizeof( delta_t ));
pField = dt->pFields;
delta_t *pField = dt->pFields;
dt->numFields = 0;
// assume we have handled '{'
@@ -870,19 +848,16 @@ static void Delta_ParseTable( char **delta_script, delta_info_t *dt, const char
static void Delta_InitFields( void )
{
byte *afile;
char *pfile;
string encodeDll, encodeFunc, token;
delta_info_t *dt;
string encodeDll, encodeFunc, token;
afile = FS_LoadFile( DELTA_PATH, NULL, false );
byte *afile = FS_LoadFile( DELTA_PATH, NULL, false );
if( !afile ) Sys_Error( "%s: couldn't load file %s\n", __func__, DELTA_PATH );
pfile = (char *)afile;
char *pfile = (char *)afile;
while(( pfile = COM_ParseFile( pfile, token, sizeof( token ))) != NULL )
{
dt = Delta_FindStruct( token );
delta_info_t *dt = Delta_FindStruct( token );
if( dt == NULL )
{
@@ -911,15 +886,13 @@ static void Delta_InitFields( void )
void Delta_Init( void )
{
delta_info_t *dt;
// shutdown it first
if( delta_init ) Delta_Shutdown ();
Delta_InitFields (); // initialize fields
delta_init = true;
dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
Assert( dt != NULL );
@@ -972,12 +945,12 @@ void Delta_Init( void )
void Delta_InitClient( void )
{
int i, numActive = 0;
int numActive = 0;
// already initalized
if( delta_init ) return;
for( i = 0; i < ARRAYSIZE( dt_info ); i++ )
for( int i = 0; i < ARRAYSIZE( dt_info ); i++ )
{
if( dt_info[i].numFields > 0 )
{
@@ -991,11 +964,9 @@ void Delta_InitClient( void )
void Delta_Shutdown( void )
{
int i;
if( !delta_init ) return;
for( i = 0; i < ARRAYSIZE( dt_info ); i++ )
for( int i = 0; i < ARRAYSIZE( dt_info ); i++ )
{
dt_info[i].numFields = 0;
dt_info[i].customEncode = CUSTOM_NONE;
@@ -1172,11 +1143,8 @@ compare baselines to find optimal
*/
int Delta_TestBaseline( const entity_state_t *from, const entity_state_t *to, qboolean player, double timebase )
{
delta_info_t *dt = NULL;
delta_t *pField;
int i, countBits;
countBits = MAX_ENTITY_BITS + 2;
delta_info_t *dt = NULL;
int countBits = MAX_ENTITY_BITS + 2;
if( to == NULL )
{
@@ -1194,14 +1162,14 @@ int Delta_TestBaseline( const entity_state_t *from, const entity_state_t *to, qb
countBits++; // entityType flag
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
// flag about field change (sets always)
countBits++;
@@ -1489,10 +1457,9 @@ static void Delta_ParseGSFields( sizebuf_t *msg, const delta_info_t *dt, const v
{
uint8_t bits[8] = { 0 };
delta_t *pField;
byte c;
int i;
c = MSG_ReadUBitLong( msg, 3 );
byte c = MSG_ReadUBitLong( msg, 3 );
for( i = 0; i < c; i++ )
bits[i] = MSG_ReadByte( msg );
@@ -1564,21 +1531,17 @@ MSG_WriteDeltaUsercmd
*/
void MSG_WriteDeltaUsercmd( sizebuf_t *msg, const usercmd_t *from, const usercmd_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_USERCMD_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_USERCMD_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_WriteField( msg, pField, from, to, 0.0f );
}
@@ -1591,20 +1554,16 @@ MSG_ReadDeltaUsercmd
*/
void MSG_ReadDeltaUsercmd( sizebuf_t *msg, const usercmd_t *from, usercmd_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_USERCMD_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_USERCMD_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
*to = *from;
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, 0.0f );
}
@@ -1626,21 +1585,17 @@ MSG_WriteDeltaEvent
*/
void MSG_WriteDeltaEvent( sizebuf_t *msg, const event_args_t *from, const event_args_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_EVENT_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_EVENT_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_WriteField( msg, pField, from, to, 0.0f );
}
@@ -1653,20 +1608,16 @@ MSG_ReadDeltaEvent
*/
void MSG_ReadDeltaEvent( sizebuf_t *msg, const event_args_t *from, event_args_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_EVENT_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_EVENT_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
*to = *from;
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, 0.0f );
}
@@ -1681,18 +1632,15 @@ movevars_t communication
*/
qboolean MSG_WriteDeltaMovevars( sizebuf_t *msg, const movevars_t *from, const movevars_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i, startBit;
int numChanges = 0;
int numChanges = 0;
dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
startBit = msg->iCurBit;
int startBit = msg->iCurBit;
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
@@ -1700,7 +1648,7 @@ qboolean MSG_WriteDeltaMovevars( sizebuf_t *msg, const movevars_t *from, const m
MSG_BeginServerCmd( msg, svc_deltamovevars );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, 0.0f ))
numChanges++;
@@ -1717,20 +1665,16 @@ qboolean MSG_WriteDeltaMovevars( sizebuf_t *msg, const movevars_t *from, const m
void MSG_ReadDeltaMovevars( sizebuf_t *msg, const movevars_t *from, movevars_t *to )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_MOVEVARS_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
*to = *from;
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, 0.0f );
}
@@ -1753,18 +1697,15 @@ Other clients can grab the client state from entity_state_t
*/
void MSG_WriteClientData( sizebuf_t *msg, const clientdata_t *from, const clientdata_t *to, double timebase )
{
delta_t *pField;
delta_info_t *dt;
int i, startBit;
int numChanges = 0;
int numChanges = 0;
dt = Delta_FindStructByIndex( DT_CLIENTDATA_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_CLIENTDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
startBit = msg->iCurBit;
int startBit = msg->iCurBit;
MSG_WriteOneBit( msg, 1 ); // have clientdata
@@ -1772,7 +1713,7 @@ void MSG_WriteClientData( sizebuf_t *msg, const clientdata_t *from, const client
Delta_CustomEncode( dt, from, to );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, timebase ))
numChanges++;
@@ -1794,21 +1735,16 @@ Read the clientdata
void MSG_ReadClientData( sizebuf_t *msg, const clientdata_t *from, clientdata_t *to, double timebase )
{
#if !XASH_DEDICATED
delta_t *pField;
delta_info_t *dt;
int i;
qboolean noChanges;
dt = Delta_FindStructByIndex( DT_CLIENTDATA_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_CLIENTDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
noChanges = !MSG_ReadOneBit( msg );
qboolean noChanges = !MSG_ReadOneBit( msg );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
if( noChanges )
Delta_CopyField( pField, from, to, timebase );
@@ -1834,27 +1770,24 @@ Other clients can grab the client state from entity_state_t
*/
void MSG_WriteWeaponData( sizebuf_t *msg, const weapon_data_t *from, const weapon_data_t *to, double timebase, int index )
{
delta_t *pField;
delta_info_t *dt;
int i, startBit;
int numChanges = 0;
int numChanges = 0;
dt = Delta_FindStructByIndex( DT_WEAPONDATA_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_WEAPONDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
// activate fields and call custom encode func
Delta_CustomEncode( dt, from, to );
startBit = msg->iCurBit;
int startBit = msg->iCurBit;
MSG_WriteOneBit( msg, 1 );
MSG_WriteUBitLong( msg, index, MAX_WEAPON_BITS );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, timebase ))
numChanges++;
@@ -1873,18 +1806,14 @@ Read the clientdata
*/
void MSG_ReadWeaponData( sizebuf_t *msg, const weapon_data_t *from, weapon_data_t *to, double timebase )
{
delta_t *pField;
delta_info_t *dt;
int i;
dt = Delta_FindStructByIndex( DT_WEAPONDATA_T );
delta_info_t *dt = Delta_FindStructByIndex( DT_WEAPONDATA_T );
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, timebase );
}
@@ -1910,14 +1839,12 @@ identical, under the assumption that the in-order delta code will catch it.
*/
void MSG_WriteDeltaEntity( const entity_state_t *from, const entity_state_t *to, sizebuf_t *msg, qboolean force, int delta_type, double timebase, int baseline )
{
delta_info_t *dt = NULL;
delta_t *pField;
int i, startBit;
int numChanges = 0;
delta_info_t *dt = NULL;
int numChanges = 0;
if( to == NULL )
{
int fRemoveType;
int fRemoveType;
if( from == NULL ) return;
@@ -1935,7 +1862,7 @@ void MSG_WriteDeltaEntity( const entity_state_t *from, const entity_state_t *to,
return;
}
startBit = msg->iCurBit;
int startBit = msg->iCurBit;
if( to->number < 0 || to->number >= GI->max_edicts )
Host_Error( "%s: Bad entity number: %i\n", __func__, to->number );
@@ -1973,13 +1900,13 @@ void MSG_WriteDeltaEntity( const entity_state_t *from, const entity_state_t *to,
Assert( dt && dt->bInitialized );
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
if( delta_type == DELTA_STATIC )
{
// static entities won't to be custom encoded
for( i = 0; i < dt->numFields; i++ )
for( int i = 0; i < dt->numFields; i++ )
dt->pFields[i].bInactive = false;
}
else
@@ -1989,7 +1916,7 @@ void MSG_WriteDeltaEntity( const entity_state_t *from, const entity_state_t *to,
}
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
if( Delta_WriteField( msg, pField, from, to, timebase ))
numChanges++;
@@ -2013,10 +1940,8 @@ Can go from either a baseline or a previous packet_entity
qboolean MSG_ReadDeltaEntity( sizebuf_t *msg, const entity_state_t *from, entity_state_t *to, int number, int delta_type, double timebase )
{
#if !XASH_DEDICATED
delta_info_t *dt = NULL;
delta_t *pField;
int i, fRemoveType;
int baseline_offset = 0;
delta_info_t *dt = NULL;
int baseline_offset = 0;
if( number < 0 || number >= clgame.maxEntities )
{
@@ -2024,7 +1949,7 @@ qboolean MSG_ReadDeltaEntity( sizebuf_t *msg, const entity_state_t *from, entity
return false;
}
fRemoveType = MSG_ReadUBitLong( msg, 2 );
int fRemoveType = MSG_ReadUBitLong( msg, 2 );
if( fRemoveType )
{
@@ -2097,11 +2022,11 @@ qboolean MSG_ReadDeltaEntity( sizebuf_t *msg, const entity_state_t *from, entity
return true;
}
pField = dt->pFields;
delta_t *pField = dt->pFields;
Assert( pField != NULL );
// process fields
for( i = 0; i < dt->numFields; i++, pField++ )
for( int i = 0; i < dt->numFields; i++, pField++ )
{
Delta_ReadField( msg, pField, from, to, timebase );
}
@@ -2115,7 +2040,6 @@ void Delta_ParseTableField_GS( sizebuf_t *msg )
const char *s = MSG_ReadString( msg );
delta_info_t *dt = Delta_FindStruct( s );
goldsrc_delta_t null = { 0 };
int i, num_fields;
// delta encoders it's already initialized on this machine (local game)
if( delta_init )
@@ -2124,13 +2048,13 @@ void Delta_ParseTableField_GS( sizebuf_t *msg )
if( !dt )
Host_Error( "%s: not initialized", __func__ );
num_fields = MSG_ReadShort( msg );
int num_fields = MSG_ReadShort( msg );
if( num_fields > dt->maxFields )
Host_Error( "%s: numFields > maxFields", __func__ );
MSG_StartBitWriting( msg );
for( i = 0; i < num_fields; i++ )
for( int i = 0; i < num_fields; i++ )
{
goldsrc_delta_t to;
@@ -2157,14 +2081,11 @@ send delta communication encoding
*/
void Delta_WriteDescriptionToClient( sizebuf_t *msg )
{
int tableIndex;
int fieldIndex;
for( tableIndex = 0; tableIndex < Delta_NumTables(); tableIndex++ )
for( int tableIndex = 0; tableIndex < Delta_NumTables(); tableIndex++ )
{
delta_info_t *dt = Delta_FindStructByIndex( tableIndex );
delta_info_t *dt = Delta_FindStructByIndex( tableIndex );
for( fieldIndex = 0; fieldIndex < dt->numFields; fieldIndex++ )
for( int fieldIndex = 0; fieldIndex < dt->numFields; fieldIndex++ )
Delta_WriteTableField( msg, tableIndex, &dt->pFields[fieldIndex] );
}
}
@@ -2178,9 +2099,7 @@ void Delta_WriteDescriptionToClient( sizebuf_t *msg )
*/
void GAME_EXPORT Delta_AddEncoder( char *name, pfnDeltaEncode encodeFunc )
{
delta_info_t *dt;
dt = Delta_FindStructByEncoder( name );
delta_info_t *dt = Delta_FindStructByEncoder( name );
if( !dt || !dt->bInitialized )
{
@@ -2200,11 +2119,10 @@ void GAME_EXPORT Delta_AddEncoder( char *name, pfnDeltaEncode encodeFunc )
int GAME_EXPORT Delta_FindField( delta_t *pFields, const char *fieldname )
{
delta_info_t *dt;
delta_t *pField;
int i;
delta_t *pField;
int i;
dt = Delta_FindStructByDelta( pFields );
delta_info_t *dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || !fieldname || !fieldname[0] )
return -1;
@@ -2218,11 +2136,10 @@ int GAME_EXPORT Delta_FindField( delta_t *pFields, const char *fieldname )
void GAME_EXPORT Delta_SetField( delta_t *pFields, const char *fieldname )
{
delta_info_t *dt;
delta_t *pField;
int i;
delta_t *pField;
int i;
dt = Delta_FindStructByDelta( pFields );
delta_info_t *dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || !fieldname || !fieldname[0] )
return;
@@ -2238,11 +2155,10 @@ void GAME_EXPORT Delta_SetField( delta_t *pFields, const char *fieldname )
void GAME_EXPORT Delta_UnsetField( delta_t *pFields, const char *fieldname )
{
delta_info_t *dt;
delta_t *pField;
int i;
delta_t *pField;
int i;
dt = Delta_FindStructByDelta( pFields );
delta_info_t *dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || !fieldname || !fieldname[0] )
return;
@@ -2258,9 +2174,7 @@ void GAME_EXPORT Delta_UnsetField( delta_t *pFields, const char *fieldname )
void GAME_EXPORT Delta_SetFieldByIndex( delta_t *pFields, int fieldNumber )
{
delta_info_t *dt;
dt = Delta_FindStructByDelta( pFields );
delta_info_t *dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || fieldNumber < 0 || fieldNumber >= dt->numFields )
return;
@@ -2269,9 +2183,7 @@ void GAME_EXPORT Delta_SetFieldByIndex( delta_t *pFields, int fieldNumber )
void GAME_EXPORT Delta_UnsetFieldByIndex( delta_t *pFields, int fieldNumber )
{
delta_info_t *dt;
dt = Delta_FindStructByDelta( pFields );
delta_info_t *dt = Delta_FindStructByDelta( pFields );
if( dt == NULL || fieldNumber < 0 || fieldNumber >= dt->numFields )
return;
@@ -2287,7 +2199,6 @@ void Test_RunDelta( void )
delta_test_struct_t from, to = { 0 };
delta_test_struct_t null = { 0 };
sizebuf_t msg;
int i;
char buffer[4096] = { 0 };
const double timebase = 123.123;
@@ -2319,12 +2230,12 @@ void Test_RunDelta( void )
MSG_Init( &msg, "test message", buffer, sizeof( buffer ));
for( i = 0; i < dt->numFields; i++ )
for( int i = 0; i < dt->numFields; i++ )
Delta_WriteField( &msg, &dt->pFields[i], &null, &from, timebase );
MSG_SeekToBit( &msg, 0, SEEK_SET );
for( i = 0; i < dt->numFields; i++ )
for( int i = 0; i < dt->numFields; i++ )
Delta_ReadField( &msg, &dt->pFields[i], &null, &to, timebase );
Con_Printf( "struct as encoded to delta:\n" );

127
engine/common/net_ws.c
View File

@@ -405,8 +405,8 @@ idnewt:28000
*/
net_gai_state_t NET_StringToSockaddr( const char *s, struct sockaddr_storage *sadr, qboolean nonblocking, int family )
{
int ret = 0, port;
char *colon;
int ret = 0;
int port;
char copy[128];
byte ip6[16];
struct sockaddr_storage temp;
@@ -430,7 +430,7 @@ net_gai_state_t NET_StringToSockaddr( const char *s, struct sockaddr_storage *sa
// strip off a trailing :port if present
((struct sockaddr_in *)sadr)->sin_port = 0;
for( colon = copy; *colon; colon++ )
for( char *colon = copy; *colon; colon++ )
{
if( *colon == ':' )
{
@@ -521,7 +521,7 @@ NET_StringToFilterAdr
*/
qboolean NET_StringToFilterAdr( const char *s, netadr_t *adr, uint *prefixlen )
{
char copy[128], *temp;
char copy[128];
qboolean hasCIDR = false;
byte ip6[16];
uint len;
@@ -533,7 +533,7 @@ qboolean NET_StringToFilterAdr( const char *s, netadr_t *adr, uint *prefixlen )
// copy the string and remove CIDR prefix
Q_strncpy( copy, s, sizeof( copy ));
temp = Q_strrchr( copy, '/' );
char *temp = Q_strrchr( copy, '/' );
if( temp )
{
@@ -595,11 +595,9 @@ qboolean NET_StringToFilterAdr( const char *s, netadr_t *adr, uint *prefixlen )
if( !hasCIDR )
{
int i;
*prefixlen = 32;
for( i = 3; i >= 0; i-- )
for( int i = 3; i >= 0; i-- )
{
if( !adr->ip[i] )
*prefixlen -= 8;
@@ -609,13 +607,11 @@ qboolean NET_StringToFilterAdr( const char *s, netadr_t *adr, uint *prefixlen )
}
else
{
uint32_t mask;
len = bound( 0, len, 32 );
*prefixlen = len;
// drop unneeded bits
mask = htonl( adr->ip4 ) & ( 0xFFFFFFFF << ( 32 - len ));
uint32_t mask = htonl( adr->ip4 ) & ( 0xFFFFFFFF << ( 32 - len ));
adr->ip4 = ntohl( mask );
}
@@ -864,17 +860,17 @@ guaranteed to return -1, 0 or 1
int NET_CompareAdrSort( const void *_a, const void *_b )
{
const netadr_t *a = _a, *b = _b;
int porta, portb, portdiff, addrdiff;
netadrtype_t type_a, type_b;
int addrdiff;
type_a = NET_NetadrType( a );
type_b = NET_NetadrType( b );
netadrtype_t type_a = NET_NetadrType( a );
netadrtype_t type_b = NET_NetadrType( b );
if( type_a != type_b )
return bound( -1, (int)type_a - (int)type_b, 1 );
porta = ntohs( a->port );
portb = ntohs( b->port );
int porta = ntohs( a->port );
int portb = ntohs( b->port );
int portdiff;
if( porta < portb )
portdiff = -1;
else if( porta > portb )
@@ -944,7 +940,6 @@ qboolean NET_StringToAdr( const char *string, netadr_t *adr )
net_gai_state_t NET_StringToAdrNB( const char *string, netadr_t *adr, qboolean v6only )
{
struct sockaddr_storage s;
net_gai_state_t res;
memset( adr, 0, sizeof( netadr_t ));
@@ -954,7 +949,7 @@ net_gai_state_t NET_StringToAdrNB( const char *string, netadr_t *adr, qboolean v
return NET_EAI_OK;
}
res = NET_StringToSockaddr( string, &s, true, v6only ? AF_INET6 : AF_UNSPEC );
net_gai_state_t res = NET_StringToSockaddr( string, &s, true, v6only ? AF_INET6 : AF_UNSPEC );
if( res == NET_EAI_OK )
NET_SockadrToNetadr( &s, adr );
@@ -976,20 +971,17 @@ NET_GetLoopPacket
*/
static qboolean NET_GetLoopPacket( netsrc_t sock, netadr_t *from, byte *data, size_t *length )
{
net_loopback_t *loop;
int i;
if( !data || !length )
return false;
loop = &net.loopbacks[sock];
net_loopback_t *loop = &net.loopbacks[sock];
if( loop->send - loop->get > MAX_LOOPBACK )
loop->get = loop->send - MAX_LOOPBACK;
if( loop->get >= loop->send )
return false;
i = loop->get & MASK_LOOPBACK;
int i = loop->get & MASK_LOOPBACK;
loop->get++;
memcpy( data, loop->msgs[i].data, loop->msgs[i].datalen );
@@ -1008,12 +1000,9 @@ NET_SendLoopPacket
*/
static void NET_SendLoopPacket( netsrc_t sock, size_t length, const void *data, netadr_t to )
{
net_loopback_t *loop;
int i;
net_loopback_t *loop = &net.loopbacks[sock^1];
loop = &net.loopbacks[sock^1];
i = loop->send & MASK_LOOPBACK;
int i = loop->send & MASK_LOOPBACK;
loop->send++;
memcpy( loop->msgs[i].data, data, length );
@@ -1062,12 +1051,10 @@ double linked list remove queue
*/
static void NET_ClearLaggedList( packetlag_t *list )
{
packetlag_t *p, *n;
p = list->next;
packetlag_t *p = list->next;
while( p && p != list )
{
n = p->next;
packetlag_t *n = p->next;
NET_RemoveFromPacketList( p );
@@ -1094,8 +1081,6 @@ add lagged packet to stream
*/
static void NET_AddToLagged( netsrc_t sock, packetlag_t *list, packetlag_t *packet, netadr_t *from, size_t length, const void *data, float timestamp )
{
byte *pStart;
if( packet->prev || packet->next )
return;
@@ -1104,7 +1089,7 @@ static void NET_AddToLagged( netsrc_t sock, packetlag_t *list, packetlag_t *pack
list->prev = packet;
packet->next = list;
pStart = (byte *)Z_Malloc( length );
byte *pStart = (byte *)Z_Malloc( length );
memcpy( pStart, data, length );
packet->data = pStart;
packet->size = length;
@@ -1122,10 +1107,8 @@ adjust time to next fake lag
static void NET_AdjustLag( void )
{
static double lasttime = 0.0;
float diff, converge;
double dt;
dt = host.realtime - lasttime;
double dt = host.realtime - lasttime;
dt = bound( 0.0, dt, 0.1 );
lasttime = host.realtime;
@@ -1133,8 +1116,8 @@ static void NET_AdjustLag( void )
{
if( net_fakelag.value != net.fakelag )
{
diff = net_fakelag.value - net.fakelag;
converge = dt * 200.0f;
float diff = net_fakelag.value - net.fakelag;
float converge = dt * 200.0f;
if( fabs( diff ) < converge )
converge = fabs( diff );
if( diff < 0.0f )
@@ -1159,18 +1142,13 @@ add fake lagged packet into rececived message
*/
static qboolean NET_LagPacket( qboolean newdata, netsrc_t sock, netadr_t *from, size_t *length, void *data )
{
packetlag_t *pNewPacketLag;
packetlag_t *pPacket;
int ninterval;
float curtime;
if( net.fakelag <= 0.0f )
{
NET_ClearLagData( true, true );
return newdata;
}
curtime = host.realtime;
float curtime = host.realtime;
if( newdata )
{
@@ -1181,7 +1159,7 @@ static qboolean NET_LagPacket( qboolean newdata, netsrc_t sock, netadr_t *from,
net.losscount[sock]++;
if( net_fakeloss.value <= 0.0f )
{
ninterval = fabs( net_fakeloss.value );
int ninterval = fabs( net_fakeloss.value );
if( ninterval < 2 ) ninterval = 2;
if(( net.losscount[sock] % ninterval ) == 0 )
@@ -1199,12 +1177,12 @@ static qboolean NET_LagPacket( qboolean newdata, netsrc_t sock, netadr_t *from,
}
}
pNewPacketLag = (packetlag_t *)Z_Malloc( sizeof( packetlag_t ));
packetlag_t *pNewPacketLag = (packetlag_t *)Z_Malloc( sizeof( packetlag_t ));
// queue packet to simulate fake lag
NET_AddToLagged( sock, &net.lagdata[sock], pNewPacketLag, from, *length, data, curtime );
}
pPacket = net.lagdata[sock].next;
packetlag_t *pPacket = net.lagdata[sock].next;
while( pPacket != &net.lagdata[sock] )
{
@@ -1356,8 +1334,6 @@ queue normal and lagged packets
static qboolean NET_QueuePacket( int net_socket, netsrc_t sock, netadr_t *from, byte *data, size_t *length )
{
byte buf[NET_MAX_FRAGMENT];
int ret;
WSAsize_t addr_len;
struct sockaddr_storage addr = { 0 };
*length = 0;
@@ -1365,8 +1341,8 @@ static qboolean NET_QueuePacket( int net_socket, netsrc_t sock, netadr_t *from,
if( !NET_IsSocketValid( net_socket ))
return NET_LagPacket( false, sock, from, length, data );
addr_len = sizeof( addr );
ret = recvfrom( net_socket, buf, sizeof( buf ), 0, (struct sockaddr *)&addr, &addr_len );
WSAsize_t addr_len = sizeof( addr );
int ret = recvfrom( net_socket, buf, sizeof( buf ), 0, (struct sockaddr *)&addr, &addr_len );
NET_SockadrToNetadr( &addr, from );
@@ -1394,7 +1370,7 @@ static qboolean NET_QueuePacket( int net_socket, netsrc_t sock, netadr_t *from,
}
else
{
int err = WSAGetLastError();
int err = WSAGetLastError();
switch( err )
{
@@ -1464,25 +1440,22 @@ static int NET_SendLong( netsrc_t sock, int net_socket, const char *buf, size_t
if( splitsize > sizeof( SPLITPACKET ) && sock == NS_SERVER && len > splitsize )
{
char packet[SPLITPACKET_MAX_SIZE];
int total_sent, size, packet_count;
int ret, packet_number;
int body_size = splitsize - sizeof( SPLITPACKET );
SPLITPACKET *pPacket;
net.sequence_number++;
if( net.sequence_number <= 0 )
net.sequence_number = 1;
pPacket = (SPLITPACKET *)packet;
SPLITPACKET *pPacket = (SPLITPACKET *)packet;
pPacket->sequence_number = net.sequence_number;
pPacket->net_id = NET_HEADER_SPLITPACKET;
packet_number = 0;
total_sent = 0;
packet_count = (len + body_size - 1) / body_size;
int packet_number = 0;
int total_sent = 0;
int packet_count = (len + body_size - 1) / body_size;
while( len > 0 )
{
size = Q_min( body_size, len );
int size = Q_min( body_size, len );
pPacket->packet_id = (packet_number << 8) + packet_count;
memcpy( packet + sizeof( SPLITPACKET ), buf + ( packet_number * body_size ), size );
@@ -1497,7 +1470,7 @@ static int NET_SendLong( netsrc_t sock, int net_socket, const char *buf, size_t
packet_number + 1, packet_count, size, net.sequence_number, NET_AdrToString( adr ));
}
ret = sendto( net_socket, packet, size + sizeof( SPLITPACKET ), flags, (const struct sockaddr *)to, tolen );
int ret = sendto( net_socket, packet, size + sizeof( SPLITPACKET ), flags, (const struct sockaddr *)to, tolen );
if( ret < 0 ) return ret; // error
if( ret >= size )
@@ -1524,7 +1497,6 @@ NET_SendPacketEx
*/
void NET_SendPacketEx( netsrc_t sock, size_t length, const void *data, netadr_t to, size_t splitsize )
{
int ret;
struct sockaddr_storage addr = { 0 };
SOCKET net_socket = 0;
netadrtype_t type = NET_NetadrType( &to );
@@ -1553,7 +1525,7 @@ void NET_SendPacketEx( netsrc_t sock, size_t length, const void *data, netadr_t
NET_NetadrToSockadr( &to, &addr );
ret = NET_SendLong( sock, net_socket, data, length, 0, &addr, NET_SockAddrLen( &addr ), splitsize );
int ret = NET_SendLong( sock, net_socket, data, length, 0, &addr, NET_SockAddrLen( &addr ), splitsize );
if( NET_IsSocketError( ret ))
{
@@ -1601,7 +1573,7 @@ NET_IPSocket
static int NET_IPSocket( const char *net_iface, int port, int family )
{
struct sockaddr_storage addr = { 0 };
int err, net_socket;
int net_socket;
uint optval = 1;
dword _true = 1;
int pfamily = PF_INET;
@@ -1611,7 +1583,7 @@ static int NET_IPSocket( const char *net_iface, int port, int family )
if( NET_IsSocketError(( net_socket = socket( pfamily, SOCK_DGRAM, IPPROTO_UDP ))))
{
err = WSAGetLastError();
int err = WSAGetLastError();
if( err != WSAEAFNOSUPPORT )
Con_DPrintf( S_WARN "%s: port: %d socket: %s\n", __func__, port, NET_ErrorString( ));
return INVALID_SOCKET;
@@ -1680,7 +1652,7 @@ static int NET_IPSocket( const char *net_iface, int port, int family )
if( NET_IsSocketError( setsockopt( net_socket, IPPROTO_IP, IP_TOS, (const char *)&optval, sizeof( optval ))))
{
err = WSAGetLastError();
int err = WSAGetLastError();
if( err != WSAENOPROTOOPT )
Con_Printf( S_WARN "%s: port: %d setsockopt IP_TOS: %s\n", __func__, port, NET_ErrorString( ));
closesocket( net_socket );
@@ -1794,7 +1766,6 @@ static void NET_DetermineLocalAddress( void )
char buff[512];
struct sockaddr_storage address;
WSAsize_t namelen;
const char *net_addr_string;
memset( &net_local, 0, sizeof( netadr_t ));
memset( &net6_local, 0, sizeof( netadr_t ));
@@ -1822,7 +1793,7 @@ static void NET_DetermineLocalAddress( void )
if( !NET_IsSocketError( getsockname( net.ip_sockets[NS_SERVER], (struct sockaddr *)&address, &namelen )))
{
net_local.port = ((struct sockaddr_in *)&address)->sin_port;
net_addr_string = NET_AdrToString( net_local );
const char *net_addr_string = NET_AdrToString( net_local );
Con_Printf( "Server IPv4 address %s\n", net_addr_string );
Cvar_FullSet( "net_address", net_addr_string, net_address.flags );
}
@@ -1845,7 +1816,7 @@ static void NET_DetermineLocalAddress( void )
if( !NET_IsSocketError( getsockname( net.ip6_sockets[NS_SERVER], (struct sockaddr *)&address, &namelen )))
{
net6_local.port = ((struct sockaddr_in6 *)&address)->sin6_port;
net_addr_string = NET_AdrToString( net6_local );
const char *net_addr_string = NET_AdrToString( net6_local );
Con_Printf( "Server IPv6 address %s\n", net_addr_string );
Cvar_FullSet( "net6_address", net_addr_string, net6_address.flags );
}
@@ -1887,9 +1858,8 @@ void NET_Config( qboolean multiplayer, qboolean changeport )
// validate sockets for dedicated
if( Host_IsDedicated( ))
{
qboolean nov4, nov6;
nov4 = net.allow_ip && NET_IsSocketError( net.ip_sockets[NS_SERVER] );
nov6 = net.allow_ip6 && NET_IsSocketError( net.ip6_sockets[NS_SERVER] );
qboolean nov4 = net.allow_ip && NET_IsSocketError( net.ip_sockets[NS_SERVER] );
qboolean nov6 = net.allow_ip6 && NET_IsSocketError( net.ip6_sockets[NS_SERVER] );
if( nov4 && nov6 )
Host_Error( "Couldn't allocate IPv4 and IPv6 server ports.\n" );
@@ -1908,10 +1878,8 @@ void NET_Config( qboolean multiplayer, qboolean changeport )
}
else
{
int i;
// shut down any existing sockets
for( i = 0; i < NS_COUNT; i++ )
for( int i = 0; i < NS_COUNT; i++ )
{
if( NET_IsSocketValid( net.ip_sockets[i] ))
{
@@ -1989,7 +1957,6 @@ NET_Init
void NET_Init( void )
{
char cmd[64];
int i = 1;
if( net.initialized ) return;
@@ -2014,7 +1981,7 @@ void NET_Init( void )
Cvar_RegisterVariable( &net6_address );
// prepare some network data
for( i = 0; i < NS_COUNT; i++ )
for( int i = 0; i < NS_COUNT; i++ )
{
net.lagdata[i].prev = &net.lagdata[i];
net.lagdata[i].next = &net.lagdata[i];

109
engine/common/pm_surface.c
View File

@@ -53,10 +53,6 @@ static int PM_SampleMiptex( const msurface_t *surf, const vec3_t point )
mextrasurf_t *info = surf->info;
mfacebevel_t *fb = info->bevel;
int contents;
vec_t ds, dt;
int x, y;
mtexinfo_t *tx;
texture_t *mt;
// fill the default contents
if( fb ) contents = fb->contents;
@@ -65,8 +61,8 @@ static int PM_SampleMiptex( const msurface_t *surf, const vec3_t point )
if( !surf->texinfo || !surf->texinfo->texture )
return contents;
tx = surf->texinfo;
mt = tx->texture;
mtexinfo_t *tx = surf->texinfo;
texture_t *mt = tx->texture;
if( mt->name[0] != '{' )
return contents;
@@ -76,18 +72,16 @@ static int PM_SampleMiptex( const msurface_t *surf, const vec3_t point )
#if !XASH_DEDICATED
if( !Host_IsDedicated() )
{
const byte *data;
data = ref.dllFuncs.R_GetTextureOriginalBuffer( mt->gl_texturenum );
const byte *data = ref.dllFuncs.R_GetTextureOriginalBuffer( mt->gl_texturenum );
if( !data ) return contents; // original doesn't kept
ds = DotProduct( point, tx->vecs[0] ) + tx->vecs[0][3];
dt = DotProduct( point, tx->vecs[1] ) + tx->vecs[1][3];
vec_t ds = DotProduct( point, tx->vecs[0] ) + tx->vecs[0][3];
vec_t dt = DotProduct( point, tx->vecs[1] ) + tx->vecs[1][3];
// convert ST to real pixels position
x = fix_coord( ds, mt->width - 1 );
y = fix_coord( dt, mt->height - 1 );
int x = fix_coord( ds, mt->width - 1 );
int y = fix_coord( dt, mt->height - 1 );
ASSERT( x >= 0 && y >= 0 );
@@ -108,18 +102,12 @@ PM_RecursiveSurfCheck
*/
msurface_t *PM_RecursiveSurfCheck( model_t *mod, mnode_t *node, vec3_t p1, vec3_t p2 )
{
float t1, t2, frac;
int i, side;
msurface_t *surf;
vec3_t mid;
int numsurfaces, firstsurface;
loc0:
if( node->contents < 0 )
return NULL;
t1 = PlaneDiff( p1, node->plane );
t2 = PlaneDiff( p2, node->plane );
float t1 = PlaneDiff( p1, node->plane );
float t2 = PlaneDiff( p2, node->plane );
if( t1 >= -FRAC_EPSILON && t2 >= -FRAC_EPSILON )
{
@@ -133,24 +121,25 @@ loc0:
goto loc0;
}
side = (t1 < 0.0f);
frac = t1 / ( t1 - t2 );
int side = (t1 < 0.0f);
float frac = t1 / ( t1 - t2 );
frac = bound( 0.0f, frac, 1.0f );
vec3_t mid;
VectorLerp( p1, frac, p2, mid );
if(( surf = PM_RecursiveSurfCheck( mod, node_child( node, side, mod ), p1, mid )) != NULL )
msurface_t *surf = PM_RecursiveSurfCheck( mod, node_child( node, side, mod ), p1, mid );
if( surf != NULL )
return surf;
// walk through real faces
numsurfaces = node_numsurfaces( node, mod );
firstsurface = node_firstsurface( node, mod );
for( i = 0; i < numsurfaces; i++ )
int numsurfaces = node_numsurfaces( node, mod );
int firstsurface = node_firstsurface( node, mod );
for( int i = 0; i < numsurfaces; i++ )
{
msurface_t *surf = &mod->surfaces[firstsurface + i];
mextrasurf_t *info = surf->info;
mfacebevel_t *fb = info->bevel;
int j, contents;
vec3_t delta;
if( !fb ) continue; // ???
@@ -159,6 +148,7 @@ loc0:
if( DotProduct( delta, delta ) >= fb->radius )
continue; // no intersection
int j;
for( j = 0; j < fb->numedges; j++ )
{
if( PlaneDiff( mid, &fb->edges[j] ) > FRAC_EPSILON )
@@ -169,7 +159,7 @@ loc0:
continue; // we are outside the bounds of the facet
// hit the surface
contents = PM_SampleMiptex( surf, mid );
int contents = PM_SampleMiptex( surf, mid );
if( contents != CONTENTS_EMPTY )
return surf;
@@ -189,27 +179,24 @@ assume physentity is valid
*/
msurface_t *PM_TraceSurface( physent_t *pe, vec3_t start, vec3_t end )
{
matrix4x4 matrix;
model_t *bmodel;
hull_t *hull;
vec3_t start_l, end_l;
vec3_t offset;
bmodel = pe->model;
model_t *bmodel = pe->model;
if( !bmodel || bmodel->type != mod_brush )
return NULL;
hull = &pe->model->hulls[0];
hull_t *hull = &pe->model->hulls[0];
vec3_t offset;
VectorSubtract( hull->clip_mins, vec3_origin, offset );
VectorAdd( offset, pe->origin, offset );
vec3_t start_l, end_l;
VectorSubtract( start, offset, start_l );
VectorSubtract( end, offset, end_l );
// rotate start and end into the models frame of reference
if( !VectorIsNull( pe->angles ))
{
matrix4x4 matrix;
Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
Matrix4x4_VectorITransform( matrix, start, start_l );
Matrix4x4_VectorITransform( matrix, end, end_l );
@@ -227,12 +214,6 @@ optimized trace for light gathering
*/
static int PM_TestLine_r( model_t *mod, mnode_t *node, vec_t p1f, vec_t p2f, const vec3_t start, const vec3_t stop, linetrace_t *trace )
{
float front, back;
float frac, midf;
int i, r, side;
vec3_t mid;
int numsurfaces, firstsurface;
loc0:
if( node->contents < 0 )
{
@@ -245,8 +226,8 @@ loc0:
return CONTENTS_EMPTY;
}
front = PlaneDiff( start, node->plane );
back = PlaneDiff( stop, node->plane );
float front = PlaneDiff( start, node->plane );
float back = PlaneDiff( stop, node->plane );
if( front >= -FRAC_EPSILON && back >= -FRAC_EPSILON )
{
@@ -260,14 +241,15 @@ loc0:
goto loc0;
}
side = (front < 0);
frac = front / (front - back);
int side = (front < 0);
float frac = front / (front - back);
frac = bound( 0.0f, frac, 1.0f );
vec3_t mid;
VectorLerp( start, frac, stop, mid );
midf = p1f + ( p2f - p1f ) * frac;
float midf = p1f + ( p2f - p1f ) * frac;
r = PM_TestLine_r( mod, node_child( node, side, mod ), p1f, midf, start, mid, trace );
int r = PM_TestLine_r( mod, node_child( node, side, mod ), p1f, midf, start, mid, trace );
if( r != CONTENTS_EMPTY )
{
@@ -278,14 +260,13 @@ loc0:
}
// walk through real faces
numsurfaces = node_numsurfaces( node, mod );
firstsurface = node_firstsurface( node, mod );
for( i = 0; i < numsurfaces; i++ )
int numsurfaces = node_numsurfaces( node, mod );
int firstsurface = node_firstsurface( node, mod );
for( int i = 0; i < numsurfaces; i++ )
{
msurface_t *surf = &mod->surfaces[firstsurface + i];
mextrasurf_t *info = surf->info;
mfacebevel_t *fb = info->bevel;
int j, contents;
vec3_t delta;
if( !fb ) continue;
@@ -294,6 +275,7 @@ loc0:
if( DotProduct( delta, delta ) >= fb->radius )
continue; // no intersection
int j;
for( j = 0; j < fb->numedges; j++ )
{
if( PlaneDiff( mid, &fb->edges[j] ) > FRAC_EPSILON )
@@ -304,7 +286,7 @@ loc0:
continue; // we are outside the bounds of the facet
// hit the surface
contents = PM_SampleMiptex( surf, mid );
int contents = PM_SampleMiptex( surf, mid );
// fill the trace and out
trace->contents = contents;
@@ -321,21 +303,15 @@ loc0:
int PM_TestLineExt( playermove_t *pmove, physent_t *ents, int numents, const vec3_t start, const vec3_t end, int flags )
{
linetrace_t trace, trace_bbox;
matrix4x4 matrix;
hull_t *hull = NULL;
vec3_t offset, start_l, end_l;
qboolean rotated;
physent_t *pe;
int i;
linetrace_t trace;
trace.contents = CONTENTS_EMPTY;
trace.fraction = 1.0f;
trace.surface = NULL;
for( i = 0; i < numents; i++ )
for( int i = 0; i < numents; i++ )
{
pe = &ents[i];
physent_t *pe = &ents[i];
if( i != 0 && FBitSet( flags, PM_WORLD_ONLY ))
break;
@@ -346,16 +322,20 @@ int PM_TestLineExt( playermove_t *pmove, physent_t *ents, int numents, const vec
if( FBitSet( flags, PM_GLASS_IGNORE ) && pe->rendermode != kRenderNormal )
continue;
hull = &pe->model->hulls[0];
hull_t *hull = &pe->model->hulls[0];
vec3_t offset;
hull = PM_HullForBsp( pe, pmove, offset );
qboolean rotated;
if( pe->solid == SOLID_BSP && !VectorIsNull( pe->angles ))
rotated = true;
else rotated = false;
vec3_t start_l, end_l;
if( rotated )
{
matrix4x4 matrix;
Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
Matrix4x4_VectorITransform( matrix, start, start_l );
Matrix4x4_VectorITransform( matrix, end, end_l );
@@ -366,6 +346,7 @@ int PM_TestLineExt( playermove_t *pmove, physent_t *ents, int numents, const vec
VectorSubtract( end, pe->origin, end_l );
}
linetrace_t trace_bbox;
trace_bbox.contents = CONTENTS_EMPTY;
trace_bbox.fraction = 1.0f;
trace_bbox.surface = NULL;

123
engine/common/pm_trace.c
View File

@@ -63,14 +63,12 @@ can just be stored out and get a proper hull_t structure.
*/
void PM_InitBoxHull( void )
{
int i;
pm_boxhull.clipnodes16 = (mclipnode16_t *)box_clipnodes16;
pm_boxhull.planes = pm_boxplanes;
pm_boxhull.firstclipnode = 0;
pm_boxhull.lastclipnode = 5;
for( i = 0; i < 6; i++ )
for( int i = 0; i < 6; i++ )
{
pm_boxplanes[i].type = i>>1;
pm_boxplanes[i].normal[i>>1] = 1.0f;
@@ -112,8 +110,6 @@ PM_HullPointContents
*/
int GAME_EXPORT PM_HullPointContents( hull_t *hull, int num, const vec3_t p )
{
mplane_t *plane;
if( !hull || !hull->planes ) // fantom bmodels?
return CONTENTS_NONE;
@@ -121,7 +117,7 @@ int GAME_EXPORT PM_HullPointContents( hull_t *hull, int num, const vec3_t p )
{
while( num >= 0 )
{
plane = &hull->planes[hull->clipnodes32[num].planenum];
mplane_t *plane = &hull->planes[hull->clipnodes32[num].planenum];
num = hull->clipnodes32[num].children[PlaneDiff( p, plane ) < 0];
}
}
@@ -129,7 +125,7 @@ int GAME_EXPORT PM_HullPointContents( hull_t *hull, int num, const vec3_t p )
{
while( num >= 0 )
{
plane = &hull->planes[hull->clipnodes16[num].planenum];
mplane_t *plane = &hull->planes[hull->clipnodes16[num].planenum];
num = hull->clipnodes16[num].children[PlaneDiff( p, plane ) < 0];
}
}
@@ -145,11 +141,10 @@ assume physent is valid
*/
hull_t *PM_HullForBsp( physent_t *pe, playermove_t *pmove, float *offset )
{
hull_t *hull;
Assert( pe != NULL );
Assert( pe->model != NULL );
hull_t *hull;
switch( pmove->usehull )
{
case 1:
@@ -184,8 +179,7 @@ generate multiple hulls as hitboxes
*/
static hull_t *PM_HullForStudio( physent_t *pe, playermove_t *pmove, int *numhitboxes )
{
vec3_t size;
vec3_t size;
VectorSubtract( host.player_maxs[pmove->usehull], host.player_mins[pmove->usehull], size );
VectorScale( size, 0.5f, size );
@@ -324,25 +318,22 @@ loc0:
pmtrace_t PM_PlayerTraceExt( playermove_t *pmove, vec3_t start, vec3_t end, int flags, int numents, physent_t *ents, int ignore_pe, pfnIgnore pmFilter )
{
physent_t *pe;
matrix4x4 matrix;
pmtrace_t trace_bbox;
pmtrace_t trace_hitbox;
pmtrace_t trace_total;
vec3_t offset, start_l, end_l;
vec3_t temp, mins, maxs;
int i, j, hullcount;
qboolean rotated, transform_bbox;
hull_t *hull = NULL;
pmtrace_t trace_total;
memset( &trace_total, 0, sizeof( trace_total ));
VectorCopy( end, trace_total.endpos );
trace_total.fraction = 1.0f;
trace_total.ent = -1;
for( i = 0; i < numents; i++ )
for( int i = 0; i < numents; i++ )
{
pe = &ents[i];
physent_t *pe = &ents[i];
matrix4x4 matrix;
vec3_t offset, start_l, end_l;
vec3_t mins, maxs;
int hullcount;
qboolean rotated, transform_bbox;
hull_t *hull = NULL;
if( i != 0 && ( flags & PM_WORLD_ONLY ))
break;
@@ -438,7 +429,7 @@ pmtrace_t PM_PlayerTraceExt( playermove_t *pmove, vec3_t start, vec3_t end, int
World_TransformAABB( matrix, host.player_mins[pmove->usehull], host.player_maxs[pmove->usehull], mins, maxs );
VectorSubtract( hull->clip_mins, mins, offset ); // calc new local offset
for( j = 0; j < 3; j++ )
for( int j = 0; j < 3; j++ )
{
if( start_l[j] >= 0.0f )
start_l[j] -= offset[j];
@@ -455,6 +446,7 @@ pmtrace_t PM_PlayerTraceExt( playermove_t *pmove, vec3_t start, vec3_t end, int
VectorSubtract( end, offset, end_l );
}
pmtrace_t trace_bbox;
PM_InitPMTrace( &trace_bbox, end );
if( hullcount < 1 )
@@ -477,10 +469,11 @@ pmtrace_t PM_PlayerTraceExt( playermove_t *pmove, vec3_t start, vec3_t end, int
}
else
{
int last_hitgroup;
int last_hitgroup = 0;
for( last_hitgroup = 0, j = 0; j < hullcount; j++ )
for( int j = 0; j < hullcount; j++ )
{
pmtrace_t trace_hitbox;
PM_InitPMTrace( &trace_hitbox, end );
PM_RecursiveHullCheck( &hull[j], hull[j].firstclipnode, 0, 1, start_l, end_l, &trace_hitbox );
@@ -513,6 +506,7 @@ pmtrace_t PM_PlayerTraceExt( playermove_t *pmove, vec3_t start, vec3_t end, int
if( rotated )
{
vec3_t temp;
VectorCopy( trace_bbox.plane.normal, temp );
Matrix4x4_TransformPositivePlane( matrix, temp, trace_bbox.plane.dist, trace_bbox.plane.normal, &trace_bbox.plane.dist );
}
@@ -534,19 +528,16 @@ pmtrace_t PM_PlayerTraceExt( playermove_t *pmove, vec3_t start, vec3_t end, int
int PM_TestPlayerPosition( playermove_t *pmove, vec3_t pos, pmtrace_t *ptrace, pfnIgnore pmFilter )
{
int i, j, hullcount;
vec3_t pos_l, offset;
hull_t *hull = NULL;
vec3_t mins, maxs;
pmtrace_t trace;
physent_t *pe;
trace = PM_PlayerTraceExt( pmove, pmove->origin, pmove->origin, 0, pmove->numphysent, pmove->physents, -1, pmFilter );
pmtrace_t trace = PM_PlayerTraceExt( pmove, pmove->origin, pmove->origin, 0, pmove->numphysent, pmove->physents, -1, pmFilter );
if( ptrace ) *ptrace = trace;
for( i = 0; i < pmove->numphysent; i++ )
for( int i = 0; i < pmove->numphysent; i++ )
{
pe = &pmove->physents[i];
physent_t *pe = &pmove->physents[i];
vec3_t pos_l, offset;
vec3_t mins, maxs;
hull_t *hull = NULL;
int hullcount;
// run custom user filter
if( pmFilter != NULL )
@@ -607,7 +598,7 @@ int PM_TestPlayerPosition( playermove_t *pmove, vec3_t pos, pmtrace_t *ptrace, p
World_TransformAABB( matrix, host.player_mins[pmove->usehull], host.player_maxs[pmove->usehull], mins, maxs );
VectorSubtract( hull->clip_mins, mins, offset ); // calc new local offset
for( j = 0; j < 3; j++ )
for( int j = 0; j < 3; j++ )
{
if( pos_l[j] >= 0.0f )
pos_l[j] -= offset[j];
@@ -645,7 +636,7 @@ int PM_TestPlayerPosition( playermove_t *pmove, vec3_t pos, pmtrace_t *ptrace, p
}
else
{
for( j = 0; j < hullcount; j++ )
for( int j = 0; j < hullcount; j++ )
{
if( PM_HullPointContents( &hull[j], hull[j].firstclipnode, pos_l ) == CONTENTS_SOLID )
return i;
@@ -684,21 +675,16 @@ PM_PointContents
*/
int PM_PointContents( playermove_t *pmove, const vec3_t p )
{
int i, contents;
hull_t *hull;
vec3_t test;
physent_t *pe;
// sanity check
if( !p || !pmove->physents[0].model )
return CONTENTS_NONE;
// get base contents from world
contents = PM_HullPointContents( &pmove->physents[0].model->hulls[0], 0, p );
int contents = PM_HullPointContents( &pmove->physents[0].model->hulls[0], 0, p );
for( i = 1; i < pmove->numphysent; i++ )
for( int i = 1; i < pmove->numphysent; i++ )
{
pe = &pmove->physents[i];
physent_t *pe = &pmove->physents[i];
if( pe->solid != SOLID_NOT ) // disabled ?
continue;
@@ -707,11 +693,12 @@ int PM_PointContents( playermove_t *pmove, const vec3_t p )
if( !pe->model ) continue;
// check water brushes accuracy
hull = &pe->model->hulls[0];
hull_t *hull = &pe->model->hulls[0];
vec3_t test;
if( FBitSet( pe->model->flags, MODEL_HAS_ORIGIN ) && !VectorIsNull( pe->angles ))
{
matrix4x4 matrix;
matrix4x4 matrix;
Matrix4x4_CreateFromEntity( matrix, pe->angles, pe->origin, 1.0f );
Matrix4x4_VectorITransform( matrix, p, test );
@@ -742,26 +729,24 @@ PM_TraceModel
*/
float PM_TraceModel( playermove_t *pmove, physent_t *pe, float *start, float *end, trace_t *trace )
{
int old_usehull;
vec3_t start_l, end_l;
vec3_t offset, temp;
qboolean rotated;
matrix4x4 matrix;
hull_t *hull;
PM_InitTrace( trace, end );
old_usehull = pmove->usehull;
int old_usehull = pmove->usehull;
pmove->usehull = 2;
hull = PM_HullForBsp( pe, pmove, offset );
vec3_t offset;
hull_t *hull = PM_HullForBsp( pe, pmove, offset );
pmove->usehull = old_usehull;
qboolean rotated;
if( pe->solid == SOLID_BSP && !VectorIsNull( pe->angles ))
rotated = true;
else rotated = false;
vec3_t start_l, end_l;
matrix4x4 matrix;
if( rotated )
{
Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
@@ -779,6 +764,7 @@ float PM_TraceModel( playermove_t *pmove, physent_t *pe, float *start, float *en
if( rotated )
{
vec3_t temp;
VectorCopy( trace->plane.normal, temp );
Matrix4x4_TransformPositivePlane( matrix, temp, trace->plane.dist, trace->plane.normal, &trace->plane.dist );
}
@@ -790,10 +776,8 @@ float PM_TraceModel( playermove_t *pmove, physent_t *pe, float *start, float *en
pmtrace_t *PM_TraceLine( playermove_t *pmove, float *start, float *end, int flags, int usehull, int ignore_pe )
{
static pmtrace_t tr;
int old_usehull;
old_usehull = pmove->usehull;
static pmtrace_t tr;
int old_usehull = pmove->usehull;
pmove->usehull = usehull;
switch( flags )
@@ -813,10 +797,8 @@ pmtrace_t *PM_TraceLine( playermove_t *pmove, float *start, float *end, int flag
pmtrace_t *PM_TraceLineEx( playermove_t *pmove, float *start, float *end, int flags, int usehull, pfnIgnore pmFilter )
{
static pmtrace_t tr;
int old_usehull;
old_usehull = pmove->usehull;
static pmtrace_t tr;
int old_usehull = pmove->usehull;
pmove->usehull = usehull;
switch( flags )
@@ -844,12 +826,10 @@ struct msurface_s *PM_TraceSurfacePmove( playermove_t *pmove, int ground, float
const char *PM_TraceTexture( playermove_t *pmove, int ground, float *vstart, float *vend )
{
msurface_t *surf;
if( ground < 0 || ground >= pmove->numphysent )
return NULL; // bad ground
surf = PM_TraceSurface( &pmove->physents[ground], vstart, vend );
msurface_t *surf = PM_TraceSurface( &pmove->physents[ground], vstart, vend );
if( !surf || !surf->texinfo || !surf->texinfo->texture )
return NULL;
@@ -859,8 +839,7 @@ const char *PM_TraceTexture( playermove_t *pmove, int ground, float *vstart, flo
int PM_PointContentsPmove( playermove_t *pmove, const float *p, int *truecontents )
{
int cont, truecont;
int truecont, cont;
truecont = cont = PM_PointContents( pmove, p );
if( truecontents ) *truecontents = truecont;
@@ -871,9 +850,7 @@ int PM_PointContentsPmove( playermove_t *pmove, const float *p, int *truecontent
void PM_StuckTouch( playermove_t *pmove, int hitent, pmtrace_t *tr )
{
int i;
for( i = 0; i < pmove->numtouch; i++ )
for( int i = 0; i < pmove->numtouch; i++ )
{
if( pmove->touchindex[i].ent == hitent )
return;

18
engine/common/soundlib/snd_utils.c
View File

@@ -363,17 +363,14 @@ static qboolean Sound_ResampleInternal( wavdata_t *sc, int outrate, int outwidth
const int incount = sc->samples;
const int insize = sc->size;
qboolean handled = false;
double stepscale;
double t1, t2;
int outcount;
if( inrate == outrate && inwidth == outwidth && inchannels == outchannels )
return false;
t1 = Platform_DoubleTime();
double t1 = Platform_DoubleTime();
stepscale = (double)inrate / outrate; // this is usually 0.5, 1, or 2
outcount = sc->samples / stepscale;
double stepscale = (double)inrate / outrate; // this is usually 0.5, 1, or 2
int outcount = sc->samples / stepscale;
sc->size = outcount * outwidth * outchannels;
sc->channels = outchannels;
@@ -404,7 +401,7 @@ static qboolean Sound_ResampleInternal( wavdata_t *sc, int outrate, int outwidth
return false;
}
t2 = Platform_DoubleTime();
double t2 = Platform_DoubleTime();
sc->rate = outrate;
sc->width = outwidth;
@@ -418,8 +415,8 @@ static qboolean Sound_ResampleInternal( wavdata_t *sc, int outrate, int outwidth
qboolean Sound_Process( wavdata_t **wav, int rate, int width, int channels, uint flags )
{
wavdata_t *snd = *wav;
qboolean result = true;
wavdata_t *snd = *wav;
qboolean result = true;
// check for buffers
if( unlikely( !snd || !snd->buffer ))
@@ -446,10 +443,9 @@ qboolean Sound_Process( wavdata_t **wav, int rate, int width, int channels, uint
qboolean Sound_SupportedFileFormat( const char *fileext )
{
const loadwavfmt_t *format;
if( !COM_StringEmpty( fileext ))
{
for( format = sound.loadformats; format && format->ext; format++ )
for( const loadwavfmt_t *format = sound.loadformats; format && format->ext; format++ )
{
if( !Q_stricmp( format->ext, fileext ))
return true;

36
engine/common/sounds.c
View File

@@ -59,9 +59,7 @@ static void SoundList_Free( soundlst_t *lst )
void SoundList_Shutdown( void )
{
int i;
for( i = 0; i < SoundList_Groups; i++ )
for( int i = 0; i < SoundList_Groups; i++ )
SoundList_Free( &soundlst[i] );
}
@@ -120,15 +118,11 @@ const char *SoundList_GetRandom( enum soundlst_group_e group )
static qboolean SoundList_ParseGroup( soundlst_t *lst, char **file )
{
string token;
int count = 0, slen = 0, i;
char *p;
p = *file;
int count = 0, slen = 0;
char *p = *file;
while(( p = COM_ParseFile( p, token, sizeof( token ))))
{
int len;
if( !Q_strcmp( token, "}" ))
break;
@@ -143,7 +137,7 @@ static qboolean SoundList_ParseGroup( soundlst_t *lst, char **file )
return false;
}
len = Q_strlen( token ) + 1;
int len = Q_strlen( token ) + 1;
if( slen < len )
slen = len;
@@ -163,7 +157,7 @@ static qboolean SoundList_ParseGroup( soundlst_t *lst, char **file )
lst->max = count;
lst->snd = Mem_Malloc( host.mempool, count * slen ); // allocate single buffer for the whole group
for( i = 0; i < count; i++ )
for( int i = 0; i < count; i++ )
{
*file = COM_ParseFile( *file, token, sizeof( token ));
@@ -176,15 +170,13 @@ static qboolean SoundList_ParseGroup( soundlst_t *lst, char **file )
static qboolean SoundList_ParseRange( soundlst_t *lst, char **file )
{
string token, snd;
char *p;
int i = 0;
lst->type = SoundList_Range;
*file = COM_ParseFile( *file, snd, sizeof( snd ));
// validate format string, count all % characters
p = snd;
i = 0;
char *p = snd;
int i = 0;
while(( p = Q_strchr( p, '%' )))
{
// only decimal
@@ -228,14 +220,12 @@ static qboolean SoundList_ParseRange( soundlst_t *lst, char **file )
static qboolean SoundList_Parse( char *file )
{
string token;
int i;
while(( file = COM_ParseFile( file, token, sizeof( token ))))
{
soundlst_t *lst = NULL;
char *p;
for( i = 0; i < SoundList_Groups; i++ )
for( int i = 0; i < SoundList_Groups; i++ )
{
if( !Q_strcmp( token, soundlst_groups[i] ))
{
@@ -250,7 +240,7 @@ static qboolean SoundList_Parse( char *file )
goto cleanup;
}
p = COM_ParseFile( file, token, sizeof( token ));
char *p = COM_ParseFile( file, token, sizeof( token ));
// group is a range
if( !Q_strcmp( token, "{" ))
@@ -287,9 +277,7 @@ cleanup:
static void SoundList_Print_f( void )
{
int i;
for( i = 0; i < SoundList_Groups; i++ )
for( int i = 0; i < SoundList_Groups; i++ )
{
soundlst_t *lst = &soundlst[i];
@@ -301,10 +289,8 @@ static void SoundList_Print_f( void )
break;
case SoundList_List:
{
int j;
Con_Reportf( "%-16s\t" S_MAGENTA "List" S_DEFAULT " [", soundlst_groups[i] );
for( j = 0; j < lst->max; j++ )
for( int j = 0; j < lst->max; j++ )
Con_Reportf( "%s%s", &lst->snd[j * lst->min], j + 1 == lst->max ? "" : ", " );
Con_Reportf( "]\n" );
break;

15
engine/common/sys_con.c
View File

@@ -82,8 +82,6 @@ static void Sys_FlushLogfile( void )
void Sys_InitLog( void )
{
const char *mode;
if( Sys_CheckParm( "-log" ))
{
if( !Sys_GetParmFromCmdLine( "-log", s_ld.log_path ) || !isalnum((byte)s_ld.log_path[0] ))
@@ -95,6 +93,7 @@ void Sys_InitLog( void )
s_ld.log_time = Sys_CheckParm( "-logtime" );
const char *mode;
if( host.change_game && host.type != HOST_DEDICATED )
mode = "a";
else mode = "w";
@@ -282,15 +281,15 @@ static void Sys_PrintStdout( const char *logtime, size_t logtime_len, const char
void Sys_PrintLog( const char *pMsg )
{
time_t crt_time;
const struct tm *crt_tm;
const struct tm *crt_tm = NULL;
char logtime[32] = "";
static char lastchar;
qboolean print_time = false;
size_t len, logtime_len = 0;
size_t logtime_len = 0;
if( !lastchar || lastchar == '\n' )
{
time_t crt_time;
if( time( &crt_time ) >= 0 )
{
crt_tm = localtime( &crt_time );
@@ -307,7 +306,7 @@ void Sys_PrintLog( const char *pMsg )
// spew to stdout
Sys_PrintStdout( logtime, logtime_len, pMsg );
len = Q_strlen( pMsg );
size_t len = Q_strlen( pMsg );
// save last char to detect when line was not ended
lastchar = len > 0 ? pMsg[len - 1] : 0;
@@ -341,9 +340,7 @@ CONSOLE PRINT
static void Con_Printfv( qboolean debug, const char *szFmt, va_list args )
{
static char buffer[MAX_PRINT_MSG];
qboolean add_newline;
add_newline = Q_vsnprintf( buffer, sizeof( buffer ), szFmt, args ) < 0;
qboolean add_newline = Q_vsnprintf( buffer, sizeof( buffer ), szFmt, args ) < 0;
if( debug && !Q_strcmp( buffer, "0\n" ))
return; // hlrally spam

26
engine/common/system.c
View File

@@ -176,14 +176,13 @@ Sys_ParseCommandLine
void Sys_ParseCommandLine( int argc, const char **argv )
{
const char *blank = "censored";
int i;
host.argc = argc;
host.argv = argv;
if( !host.change_game ) return;
for( i = 0; i < host.argc; i++ )
for( int i = 0; i < host.argc; i++ )
{
// we don't want to return to first game
if( !Q_stricmp( "-game", host.argv[i] )) host.argv[i] = blank;
@@ -208,9 +207,7 @@ where the given parameter apears, or 0 if not present
*/
int Sys_CheckParm( const char *parm )
{
int i;
for( i = 1; i < host.argc; i++ )
for( int i = 1; i < host.argc; i++ )
{
if( !host.argv[i] )
continue;
@@ -259,7 +256,6 @@ qboolean Sys_GetIntFromCmdLine( const char* argName, int *out )
//=======================================================================
qboolean Sys_LoadLibrary( dll_info_t *dll )
{
size_t i;
string errorstring;
// check errors
@@ -285,7 +281,7 @@ qboolean Sys_LoadLibrary( dll_info_t *dll )
}
// Get the function adresses
for( i = 0; i < dll->num_fcts; i++ )
for( size_t i = 0; i < dll->num_fcts; i++ )
{
const dllfunc_t *func = &dll->fcts[i];
if( !( *func->func = COM_GetProcAddress( dll->link, func->name )))
@@ -557,13 +553,12 @@ it explicitly doesn't use internal allocation or string copy utils
qboolean Sys_NewInstance( const char *gamedir, const char *finalmsg )
{
qboolean replaced_arg = false;
int i;
#if XASH_NSWITCH
char newargs[4096];
const char *exe = host.argv[0]; // arg 0 is always the full NRO path
for( i = 0; i < host.argc; i++ )
for( int i = 0; i < host.argc; i++ )
{
Q_strncat( newargs, host.argv[i], sizeof( newargs ));
Q_strncat( newargs, " ", sizeof( newargs ));
@@ -593,12 +588,11 @@ qboolean Sys_NewInstance( const char *gamedir, const char *finalmsg )
envSetNextLoad( exe, newargs );
exit( 0 );
#else
int exelen;
char *exe = NULL, **newargs;
char *exe = NULL;
// don't use engine allocation utils here
// they will be freed after Host_Shutdown
newargs = calloc( host.argc + 4, sizeof( *newargs ));
char **newargs = calloc( host.argc + 4, sizeof( *newargs ));
int i;
for( i = 0; i < host.argc; i++ )
{
@@ -628,7 +622,7 @@ qboolean Sys_NewInstance( const char *gamedir, const char *finalmsg )
exe = strdup( "app0:/eboot.bin" );
sceAppMgrLoadExec( exe, newargs, NULL );
#else
exelen = wai_getExecutablePath( NULL, 0, NULL );
int exelen = wai_getExecutablePath( NULL, 0, NULL );
if( exelen >= 0 )
{
exe = malloc( exelen + 1 );
@@ -661,15 +655,13 @@ Get platform-specific native object
*/
void *Sys_GetNativeObject( const char *obj )
{
void *ptr;
if( COM_StringEmptyOrNULL( obj ))
return NULL;
if( !Q_strcmp( obj, "MenuFactory" ))
return UI_GetMenuFactory();
ptr = FS_GetNativeObject( obj );
void *ptr = FS_GetNativeObject( obj );
if( ptr )
return ptr;

10
engine/common/world.c
View File

@@ -28,18 +28,16 @@ World_TransformAABB
*/
void World_TransformAABB( matrix4x4 transform, const vec3_t mins, const vec3_t maxs, vec3_t outmins, vec3_t outmaxs )
{
vec3_t p1, p2;
matrix4x4 itransform;
int i;
if( !outmins || !outmaxs ) return;
matrix4x4 itransform;
Matrix4x4_Invert_Simple( itransform, transform );
ClearBounds( outmins, outmaxs );
// compute a full bounding box
for( i = 0; i < 8; i++ )
for( int i = 0; i < 8; i++ )
{
vec3_t p1, p2;
p1[0] = ( i & 1 ) ? mins[0] : maxs[0];
p1[1] = ( i & 2 ) ? mins[1] : maxs[1];
p1[2] = ( i & 4 ) ? mins[2] : maxs[2];
@@ -57,7 +55,7 @@ void World_TransformAABB( matrix4x4 transform, const vec3_t mins, const vec3_t m
}
// sanity check
for( i = 0; i < 3; i++ )
for( int i = 0; i < 3; i++ )
{
if( outmins[i] > outmaxs[i] )
{

32
engine/common/zone.c
View File

@@ -31,15 +31,13 @@ GNU General Public License for more details.
static void *Q_realloc( void *mem, size_t size )
{
void *newmem;
if( mem && size == 0 )
{
Q_free( mem );
return NULL;
}
newmem = Q_malloc( size );
void *newmem = Q_malloc( size );
if( mem && newmem )
{
memcpy( newmem, mem, size );
@@ -577,7 +575,6 @@ static qboolean Mem_CheckAlloc( mempool_t *pool, void *data )
if( pool )
{
memheader_t *target_big = (memheader_t *)((byte *)data - sizeof( memheader_t ));
memheader_small_t *target_small = (memheader_small_t *)((byte *)data - sizeof( memheader_small_t ));
for( memheader_t *header = pool->chain; header; header = header->next )
{
@@ -585,6 +582,8 @@ static qboolean Mem_CheckAlloc( mempool_t *pool, void *data )
return true;
}
memheader_small_t *target_small = (memheader_small_t *)((byte *)data - sizeof( memheader_small_t ));
for( memheader_small_t *header = pool->chain_small; header; header = header->next )
{
if( header == target_small )
@@ -593,10 +592,9 @@ static qboolean Mem_CheckAlloc( mempool_t *pool, void *data )
}
else
{
size_t i;
for( i = 0, pool = poolchain; i < poolcount; i++, pool++ )
for( size_t i = 0; i < poolcount; i++ )
{
if( Mem_CheckAlloc( pool, data ))
if( Mem_CheckAlloc( &poolchain[i], data ))
return true;
}
}
@@ -615,11 +613,10 @@ qboolean Mem_IsAllocatedExt( poolhandle_t poolptr, void *data )
void _Mem_Check( const char *filename, int fileline )
{
mempool_t *pool;
size_t i;
for( i = 0, pool = poolchain; i < poolcount; i++, pool++ )
for( size_t i = 0; i < poolcount; i++ )
{
mempool_t *pool = &poolchain[i];
for( memheader_t *mem = pool->chain; mem; mem = mem->next )
Mem_CheckAllocHeaderBig( __func__, mem, filename, fileline );
@@ -630,12 +627,13 @@ void _Mem_Check( const char *filename, int fileline )
void Mem_PrintStats( void )
{
size_t count = 0, size = 0, realsize = 0, i;
mempool_t *pool;
size_t count = 0, size = 0, realsize = 0;
Mem_Check();
for( i = 0, pool = poolchain; i < poolcount; i++, pool++ )
for( size_t i = 0; i < poolcount; i++ )
{
mempool_t *pool = &poolchain[i];
if( !pool->filename )
continue;
@@ -650,15 +648,13 @@ void Mem_PrintStats( void )
static void Mem_PrintList( size_t minallocationsize )
{
mempool_t *pool;
size_t i;
Mem_Check();
Con_Printf( "memory pool list:\n" );
Con_Printf( "\t^3size\t\t\t\tname\n");
for( i = 0, pool = poolchain; i < poolcount; i++, pool++ )
for( size_t i = 0; i < poolcount; i++ )
{
mempool_t *pool = &poolchain[i];
long changed_size = (long)pool->totalsize - (long)pool->lastchecksize;
if( !pool->filename )