ioquake/jedi-outcast
0
0
Fork 0
mirror of https://github.com/ioquake/jedi-outcast.git synced 2024-11-10 07:11:42 +00:00
Code Issues Projects Releases Packages Wiki Activity

stricmp -> Q_stricmp

Browse source
This commit is contained in:
Jonathan Gray 2013-04-28 21:35:36 +10:00
parent 64d851b2d4
commit 33b0592a56
16 changed files with 120 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
CODE-mp/client/FxScheduler.cpp
View file

@ -659,58 +659,58 @@ int CFxScheduler::ParseEffect( const char *file, CGPGroup *base )
grpName = primitiveGroup->GetName();
// Huge stricmp lists suxor
if ( !stricmp( grpName, "particle" ))
if ( !Q_stricmp( grpName, "particle" ))
{
type = Particle;
}
else if ( !stricmp( grpName, "line" ))
else if ( !Q_stricmp( grpName, "line" ))
{
type = Line;
}
else if ( !stricmp( grpName, "tail" ))
else if ( !Q_stricmp( grpName, "tail" ))
{
type = Tail;
}
else if ( !stricmp( grpName, "sound" ))
else if ( !Q_stricmp( grpName, "sound" ))
{
type = Sound;
}
else if ( !stricmp( grpName, "cylinder" ))
else if ( !Q_stricmp( grpName, "cylinder" ))
{
type = Cylinder;
}
else if ( !stricmp( grpName, "electricity" ))
else if ( !Q_stricmp( grpName, "electricity" ))
{
type = Electricity;
}
else if ( !stricmp( grpName, "emitter" ))
else if ( !Q_stricmp( grpName, "emitter" ))
{
type = Emitter;
}
else if ( !stricmp( grpName, "decal" ))
else if ( !Q_stricmp( grpName, "decal" ))
{
type = Decal;
}
else if ( !stricmp( grpName, "orientedparticle" ))
else if ( !Q_stricmp( grpName, "orientedparticle" ))
{
type = OrientedParticle;
}
else if ( !stricmp( grpName, "fxrunner" ))
else if ( !Q_stricmp( grpName, "fxrunner" ))
{
type = FxRunner;
}
else if ( !stricmp( grpName, "light" ))
else if ( !Q_stricmp( grpName, "light" ))
{
type = Light;
}
else if ( !stricmp( grpName, "cameraShake" ))
else if ( !Q_stricmp( grpName, "cameraShake" ))
{
type = CameraShake;
}
/*
// NOTE: Pat requested that flashes be disabled in MP. Since fx files are shared with SP, this is the easiest way to accomplish that....
// code will fall through and become type NONE....and therefore not parsed and added to the effect definition.
else if ( !stricmp( grpName, "flash" ))
else if ( !Q_stricmp( grpName, "flash" ))
{
type = ScreenFlash;
}
@ -887,7 +887,7 @@ CPrimitiveTemplate *CFxScheduler::GetPrimitiveCopy( SEffectTemplate *effectCopy,
for ( int i = 0; i < effectCopy->mPrimitiveCount; i++ )
{
if ( !stricmp( effectCopy->mPrimitives[i]->mName, componentName ))
if ( !Q_stricmp( effectCopy->mPrimitives[i]->mName, componentName ))
{
// we found a match, so return it
return effectCopy->mPrimitives[i];

2
CODE-mp/client/FxScheduler.h
View file

@ -385,7 +385,7 @@ struct SEffectTemplate
bool operator == (const char * name) const
{
return !stricmp( mEffectName, name );
return !Q_stricmp( mEffectName, name );
}
void operator=(const SEffectTemplate &that);
};

172
CODE-mp/client/FxTemplate.cpp
View file

@ -273,23 +273,23 @@ bool CPrimitiveTemplate::ParseGroupFlags( const char *val, int *flags )
return true;
}
if ( !stricmp( flag[i], "linear" ))
if ( !Q_stricmp( flag[i], "linear" ))
{
*flags |= FX_LINEAR;
}
else if ( !stricmp( flag[i], "nonlinear" ))
else if ( !Q_stricmp( flag[i], "nonlinear" ))
{
*flags |= FX_NONLINEAR;
}
else if ( !stricmp( flag[i], "wave" ))
else if ( !Q_stricmp( flag[i], "wave" ))
{
*flags |= FX_WAVE;
}
else if ( !stricmp( flag[i], "random" ))
else if ( !Q_stricmp( flag[i], "random" ))
{
*flags |= FX_RAND;
}
else if ( !stricmp( flag[i], "clamp" ))
else if ( !Q_stricmp( flag[i], "clamp" ))
{
*flags |= FX_CLAMP;
}
@ -716,51 +716,51 @@ bool CPrimitiveTemplate::ParseFlags( const char *val )
return true;
}
if ( !stricmp( flag[i], "useModel" ))
if ( !Q_stricmp( flag[i], "useModel" ))
{
mFlags |= FX_ATTACHED_MODEL;
}
else if ( !stricmp( flag[i], "useBBox" ))
else if ( !Q_stricmp( flag[i], "useBBox" ))
{
mFlags |= FX_USE_BBOX;
}
else if ( !stricmp( flag[i], "usePhysics" ))
else if ( !Q_stricmp( flag[i], "usePhysics" ))
{
mFlags |= FX_APPLY_PHYSICS;
}
else if ( !stricmp( flag[i], "expensivePhysics" ))
else if ( !Q_stricmp( flag[i], "expensivePhysics" ))
{
mFlags |= FX_EXPENSIVE_PHYSICS;
}
else if ( !stricmp( flag[i], "impactKills" ))
else if ( !Q_stricmp( flag[i], "impactKills" ))
{
mFlags |= FX_KILL_ON_IMPACT;
}
else if ( !stricmp( flag[i], "impactFx" ))
else if ( !Q_stricmp( flag[i], "impactFx" ))
{
mFlags |= FX_IMPACT_RUNS_FX;
}
else if ( !stricmp( flag[i], "deathFx" ))
else if ( !Q_stricmp( flag[i], "deathFx" ))
{
mFlags |= FX_DEATH_RUNS_FX;
}
else if ( !stricmp( flag[i], "useAlpha" ))
else if ( !Q_stricmp( flag[i], "useAlpha" ))
{
mFlags |= FX_USE_ALPHA;
}
else if ( !stricmp( flag[i], "emitFx" ))
else if ( !Q_stricmp( flag[i], "emitFx" ))
{
mFlags |= FX_EMIT_FX;
}
else if ( !stricmp( flag[i], "depthHack" ))
else if ( !Q_stricmp( flag[i], "depthHack" ))
{
mFlags |= FX_DEPTH_HACK;
}
else if ( !stricmp( flag[i], "relative" ))
else if ( !Q_stricmp( flag[i], "relative" ))
{
mFlags |= FX_RELATIVE;
}
else if ( !stricmp( flag[i], "setShaderTime" ))
else if ( !Q_stricmp( flag[i], "setShaderTime" ))
{
mFlags |= FX_SET_SHADER_TIME;
}
@ -799,59 +799,59 @@ bool CPrimitiveTemplate::ParseSpawnFlags( const char *val )
return true;
}
if ( !stricmp( flag[i], "org2fromTrace" ))
if ( !Q_stricmp( flag[i], "org2fromTrace" ))
{
mSpawnFlags |= FX_ORG2_FROM_TRACE;
}
else if ( !stricmp( flag[i], "traceImpactFx" ))
else if ( !Q_stricmp( flag[i], "traceImpactFx" ))
{
mSpawnFlags |= FX_TRACE_IMPACT_FX;
}
else if ( !stricmp( flag[i], "org2isOffset" ))
else if ( !Q_stricmp( flag[i], "org2isOffset" ))
{
mSpawnFlags |= FX_ORG2_IS_OFFSET;
}
else if ( !stricmp( flag[i], "cheapOrgCalc" ))
else if ( !Q_stricmp( flag[i], "cheapOrgCalc" ))
{
mSpawnFlags |= FX_CHEAP_ORG_CALC;
}
else if ( !stricmp( flag[i], "cheapOrg2Calc" ))
else if ( !Q_stricmp( flag[i], "cheapOrg2Calc" ))
{
mSpawnFlags |= FX_CHEAP_ORG2_CALC;
}
else if ( !stricmp( flag[i], "absoluteVel" ))
else if ( !Q_stricmp( flag[i], "absoluteVel" ))
{
mSpawnFlags |= FX_VEL_IS_ABSOLUTE;
}
else if ( !stricmp( flag[i], "absoluteAccel" ))
else if ( !Q_stricmp( flag[i], "absoluteAccel" ))
{
mSpawnFlags |= FX_ACCEL_IS_ABSOLUTE;
}
else if ( !stricmp( flag[i], "orgOnSphere" ))
else if ( !Q_stricmp( flag[i], "orgOnSphere" ))
{
mSpawnFlags |= FX_ORG_ON_SPHERE;
}
else if ( !stricmp( flag[i], "orgOnCylinder" ))
else if ( !Q_stricmp( flag[i], "orgOnCylinder" ))
{
mSpawnFlags |= FX_ORG_ON_CYLINDER;
}
else if ( !stricmp( flag[i], "axisFromSphere" ))
else if ( !Q_stricmp( flag[i], "axisFromSphere" ))
{
mSpawnFlags |= FX_AXIS_FROM_SPHERE;
}
else if ( !stricmp( flag[i], "randrotaroundfwd" ))
else if ( !Q_stricmp( flag[i], "randrotaroundfwd" ))
{
mSpawnFlags |= FX_RAND_ROT_AROUND_FWD;
}
else if ( !stricmp( flag[i], "evenDistribution" ))
else if ( !Q_stricmp( flag[i], "evenDistribution" ))
{
mSpawnFlags |= FX_EVEN_DISTRIBUTION;
}
else if ( !stricmp( flag[i], "rgbComponentInterpolation" ))
else if ( !Q_stricmp( flag[i], "rgbComponentInterpolation" ))
{
mSpawnFlags |= FX_RGB_COMPONENT_INTERP;
}
else if ( !stricmp( flag[i], "affectedByWind" ))
else if ( !Q_stricmp( flag[i], "affectedByWind" ))
{
mSpawnFlags |= FX_AFFECTED_BY_WIND;
}
@ -1899,19 +1899,19 @@ bool CPrimitiveTemplate::ParseRGB( CGPGroup *grp )
val = pairs->GetTopValue();
// Huge stricmp lists suxor
if ( !stricmp( key, "start" ))
if ( !Q_stricmp( key, "start" ))
{
ParseRGBStart( val );
}
else if ( !stricmp( key, "end" ))
else if ( !Q_stricmp( key, "end" ))
{
ParseRGBEnd( val );
}
else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
{
ParseRGBParm( val );
}
else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
{
ParseRGBFlags( val );
}
@ -1953,19 +1953,19 @@ bool CPrimitiveTemplate::ParseAlpha( CGPGroup *grp )
val = pairs->GetTopValue();
// Huge stricmp lists suxor
if ( !stricmp( key, "start" ))
if ( !Q_stricmp( key, "start" ))
{
ParseAlphaStart( val );
}
else if ( !stricmp( key, "end" ))
else if ( !Q_stricmp( key, "end" ))
{
ParseAlphaEnd( val );
}
else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
{
ParseAlphaParm( val );
}
else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
{
ParseAlphaFlags( val );
}
@ -2007,19 +2007,19 @@ bool CPrimitiveTemplate::ParseSize( CGPGroup *grp )
val = pairs->GetTopValue();
// Huge stricmp lists suxor
if ( !stricmp( key, "start" ))
if ( !Q_stricmp( key, "start" ))
{
ParseSizeStart( val );
}
else if ( !stricmp( key, "end" ))
else if ( !Q_stricmp( key, "end" ))
{
ParseSizeEnd( val );
}
else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
{
ParseSizeParm( val );
}
else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
{
ParseSizeFlags( val );
}
@ -2061,19 +2061,19 @@ bool CPrimitiveTemplate::ParseSize2( CGPGroup *grp )
val = pairs->GetTopValue();
// Huge stricmp lists suxor
if ( !stricmp( key, "start" ))
if ( !Q_stricmp( key, "start" ))
{
ParseSize2Start( val );
}
else if ( !stricmp( key, "end" ))
else if ( !Q_stricmp( key, "end" ))
{
ParseSize2End( val );
}
else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
{
ParseSize2Parm( val );
}
else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
{
ParseSize2Flags( val );
}
@ -2115,19 +2115,19 @@ bool CPrimitiveTemplate::ParseLength( CGPGroup *grp )
val = pairs->GetTopValue();
// Huge stricmp lists suxor
if ( !stricmp( key, "start" ))
if ( !Q_stricmp( key, "start" ))
{
ParseLengthStart( val );
}
else if ( !stricmp( key, "end" ))
else if ( !Q_stricmp( key, "end" ))
{
ParseLengthEnd( val );
}
else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
else if ( !Q_stricmp( key, "parm" ) || !Q_stricmp( key, "parms" ))
{
ParseLengthParm( val );
}
else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
{
ParseLengthFlags( val );
}
@ -2163,112 +2163,112 @@ bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
val = pairs->GetTopValue();
// Huge stricmp lists suxor
if ( !stricmp( key, "count" ))
if ( !Q_stricmp( key, "count" ))
{
ParseCount( val );
}
else if ( !stricmp( key, "shaders" ) || !stricmp( key, "shader" ))
else if ( !Q_stricmp( key, "shaders" ) || !Q_stricmp( key, "shader" ))
{
ParseShaders( pairs );
}
else if ( !stricmp( key, "models" ) || !stricmp( key, "model" ))
else if ( !Q_stricmp( key, "models" ) || !Q_stricmp( key, "model" ))
{
ParseModels( pairs );
}
else if ( !stricmp( key, "sounds" ) || !stricmp( key, "sound" ))
else if ( !Q_stricmp( key, "sounds" ) || !Q_stricmp( key, "sound" ))
{
ParseSounds( pairs );
}
else if ( !stricmp( key, "impactfx" ))
else if ( !Q_stricmp( key, "impactfx" ))
{
ParseImpactFxStrings( pairs );
}
else if ( !stricmp( key, "deathfx" ))
else if ( !Q_stricmp( key, "deathfx" ))
{
ParseDeathFxStrings( pairs );
}
else if ( !stricmp( key, "emitfx" ))
else if ( !Q_stricmp( key, "emitfx" ))
{
ParseEmitterFxStrings( pairs );
}
else if ( !stricmp( key, "playfx" ))
else if ( !Q_stricmp( key, "playfx" ))
{
ParsePlayFxStrings( pairs );
}
else if ( !stricmp( key, "life" ))
else if ( !Q_stricmp( key, "life" ))
{
ParseLife( val );
}
else if ( !stricmp( key, "cullrange" ))
else if ( !Q_stricmp( key, "cullrange" ))
{
mCullRange = atoi( val );
mCullRange *= mCullRange; // Square
}
else if ( !stricmp( key, "delay" ))
else if ( !Q_stricmp( key, "delay" ))
{
ParseDelay( val );
}
else if ( !stricmp( key, "bounce" ) || !stricmp( key, "intensity" )) // me==bad for reusing this...but it shouldn't hurt anything)
else if ( !Q_stricmp( key, "bounce" ) || !Q_stricmp( key, "intensity" )) // me==bad for reusing this...but it shouldn't hurt anything)
{
ParseElasticity( val );
}
else if ( !stricmp( key, "min" ))
else if ( !Q_stricmp( key, "min" ))
{
ParseMin( val );
}
else if ( !stricmp( key, "max" ))
else if ( !Q_stricmp( key, "max" ))
{
ParseMax( val );
}
else if ( !stricmp( key, "angle" ) || !stricmp( key, "angles" ))
else if ( !Q_stricmp( key, "angle" ) || !Q_stricmp( key, "angles" ))
{
ParseAngle( val );
}
else if ( !stricmp( key, "angleDelta" ))
else if ( !Q_stricmp( key, "angleDelta" ))
{
ParseAngleDelta( val );
}
else if ( !stricmp( key, "velocity" ) || !stricmp( key, "vel" ))
else if ( !Q_stricmp( key, "velocity" ) || !Q_stricmp( key, "vel" ))
{
ParseVelocity( val );
}
else if ( !stricmp( key, "acceleration" ) || !stricmp( key, "accel" ))
else if ( !Q_stricmp( key, "acceleration" ) || !Q_stricmp( key, "accel" ))
{
ParseAcceleration( val );
}
else if ( !stricmp( key, "gravity" ))
else if ( !Q_stricmp( key, "gravity" ))
{
ParseGravity( val );
}
else if ( !stricmp( key, "density" ))
else if ( !Q_stricmp( key, "density" ))
{
ParseDensity( val );
}
else if ( !stricmp( key, "variance" ))
else if ( !Q_stricmp( key, "variance" ))
{
ParseVariance( val );
}
else if ( !stricmp( key, "origin" ))
else if ( !Q_stricmp( key, "origin" ))
{
ParseOrigin1( val );
}
else if ( !stricmp( key, "origin2" ))
else if ( !Q_stricmp( key, "origin2" ))
{
ParseOrigin2( val );
}
else if ( !stricmp( key, "radius" ))
else if ( !Q_stricmp( key, "radius" ))
{
ParseRadius( val );
}
else if ( !stricmp( key, "height" ))
else if ( !Q_stricmp( key, "height" ))
{
ParseHeight( val );
}
else if ( !stricmp( key, "wind" ))
else if ( !Q_stricmp( key, "wind" ))
{
ParseWindModifier( val );
}
else if ( !stricmp( key, "rotation" ))
else if ( !Q_stricmp( key, "rotation" ))
{
ParseRotation( val );
}
@ -2276,15 +2276,15 @@ bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
{
ParseRotationDelta( val );
}
else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
else if ( !Q_stricmp( key, "flags" ) || !Q_stricmp( key, "flag" ))
{ // these need to get passed on to the primitive
ParseFlags( val );
}
else if ( !stricmp( key, "spawnFlags" ) || !stricmp( key, "spawnFlag" ))
else if ( !Q_stricmp( key, "spawnFlags" ) || !Q_stricmp( key, "spawnFlag" ))
{ // these are used to spawn things in cool ways, but don't ever get passed on to prims.
ParseSpawnFlags( val );
}
else if ( !stricmp( key, "name" ))
else if ( !Q_stricmp( key, "name" ))
{
if ( val )
{
@ -2307,23 +2307,23 @@ bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
{
key = subGrp->GetName();
if ( !stricmp( key, "rgb" ))
if ( !Q_stricmp( key, "rgb" ))
{
ParseRGB( subGrp );
}
else if ( !stricmp( key, "alpha" ))
else if ( !Q_stricmp( key, "alpha" ))
{
ParseAlpha( subGrp );
}
else if ( !stricmp( key, "size" ) || !stricmp( key, "width" ))
else if ( !Q_stricmp( key, "size" ) || !Q_stricmp( key, "width" ))
{
ParseSize( subGrp );
}
else if ( !stricmp( key, "size2" ) || !stricmp( key, "width2" ))
else if ( !Q_stricmp( key, "size2" ) || !Q_stricmp( key, "width2" ))
{
ParseSize2( subGrp );
}
else if ( !stricmp( key, "length" ) || !stricmp( key, "height" ))
else if ( !Q_stricmp( key, "length" ) || !Q_stricmp( key, "height" ))
{
ParseLength( subGrp );
}

2
CODE-mp/client/cl_keys.cpp
View file

@ -1013,7 +1013,7 @@ int Key_StringToKeynum( char *str ) {
// scan for a text match
for ( i = 0 ; i < MAX_KEYS ; i++ )
{
if ( keynames[i].name && !stricmp( str, keynames[i].name ) )
if ( keynames[i].name && !Q_stricmp( str, keynames[i].name ) )
{
return keynames[i].keynum;
}

6
CODE-mp/client/snd_mem.cpp
View file

@ -281,15 +281,15 @@ static qboolean S_LoadSound_FileLoadAndNameAdjuster(char *psFilename, byte **pDa
// account for foreign voices...
//
extern cvar_t* s_language;
if (s_language && stricmp("DEUTSCH",s_language->string)==0)
if (s_language && Q_stricmp("DEUTSCH",s_language->string)==0)
{
strncpy(psVoice,"chr_d",5); // same number of letters as "chars"
}
else if (s_language && stricmp("FRANCAIS",s_language->string)==0)
else if (s_language && Q_stricmp("FRANCAIS",s_language->string)==0)
{
strncpy(psVoice,"chr_f",5); // same number of letters as "chars"
}
else if (s_language && stricmp("ESPANOL",s_language->string)==0)
else if (s_language && Q_stricmp("ESPANOL",s_language->string)==0)
{
strncpy(psVoice,"chr_e",5); // same number of letters as "chars"
}

2
CODE-mp/game/g_items.c
View file

@ -1839,7 +1839,7 @@ void FinishSpawningItem( gentity_t *ent ) {
// create a Ghoul2 model if the world model is a glm
/* item = &bg_itemlist[ ent->s.modelindex ];
if (!stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
if (!Q_stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
{
trap_G2API_InitGhoul2Model(&ent->s, item->world_model[0], G_ModelIndex(item->world_model[0] ), 0, 0, 0, 0);
ent->s.radius = 60;

9
CODE-mp/game/q_shared.h
View file

@ -124,7 +124,6 @@ static ID_INLINE float BigFloat(const float *l) { FloatSwap(l); }
#define MAC_STATIC
#define __cdecl
#define __declspec(x)
#define stricmp strcasecmp
#define ID_INLINE inline
#ifdef __ppc__
@ -200,9 +199,6 @@ static inline float LittleFloat (const float l) { return FloatSwap(&l); }
// just waste space and make big arrays static...
#ifdef __linux__
// bk001205 - from Makefile
#define stricmp strcasecmp
#define MAC_STATIC // bk: FIXME
#define ID_INLINE inline
@ -248,9 +244,6 @@ inline static float LittleFloat (const float *l) { return FloatSwap(l); }
// just waste space and make big arrays static...
#ifdef __OpenBSD__
// bk001205 - from Makefile
#define stricmp strcasecmp
#define MAC_STATIC // bk: FIXME
#define ID_INLINE inline
@ -295,8 +288,6 @@ inline static float LittleFloat (const float *l) { return FloatSwap(l); }
//======================= FreeBSD DEFINES =====================
#ifdef __FreeBSD__ // rb010123
#define stricmp strcasecmp
#define MAC_STATIC
#define ID_INLINE inline

2
CODE-mp/ghoul2/G2_bolts.cpp
View file

@ -179,7 +179,7 @@ int G2_Add_Bolt(const char *fileName, boltInfo_v &bltlist, surfaceInfo_v &slist,
{
skel = (mdxaSkel_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
// if name is the same, we found it
if (!stricmp(skel->name, boneName))
if (!Q_stricmp(skel->name, boneName))
{
break;
}

6
CODE-mp/ghoul2/G2_bones.cpp
View file

@ -47,7 +47,7 @@ int G2_Find_Bone(const model_t *mod, boneInfo_v &blist, const char *boneName)
skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
// if name is the same, we found it
if (!stricmp(skel->name, boneName))
if (!Q_stricmp(skel->name, boneName))
{
return i;
}
@ -72,7 +72,7 @@ int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName)
{
skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
// if name is the same, we found it
if (!stricmp(skel->name, boneName))
if (!Q_stricmp(skel->name, boneName))
{
break;
}
@ -94,7 +94,7 @@ int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName)
{
skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
// if name is the same, we found it
if (!stricmp(skel->name, boneName))
if (!Q_stricmp(skel->name, boneName))
{
return i;
}

2
CODE-mp/ghoul2/G2_misc.cpp
View file

@ -1650,7 +1650,7 @@ int G2_FindConfigStringSpace(char *name, int start, int max)
{
break;
}
if ( !stricmp( s, name ) )
if ( !Q_stricmp( s, name ) )
{
return i;
}

6
CODE-mp/ghoul2/G2_surfaces.cpp
View file

@ -72,7 +72,7 @@ int G2_IsSurfaceLegal(void *mod, const char *surfaceName, int *flags)
for ( int i = 0 ; i < mod_m->mdxm->numSurfaces ; i++)
{
if (!stricmp(surfaceName, surf->name))
if (!Q_stricmp(surfaceName, surf->name))
{
*flags = surf->flags;
return i;
@ -126,7 +126,7 @@ mdxmSurface_t *G2_FindSurface(const char *fileName, surfaceInfo_v &slist, const
surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
// are these the droids we're looking for?
if (!stricmp (surfInfo->name, surfaceName))
if (!Q_stricmp (surfInfo->name, surfaceName))
{
// yup
if (surfIndex)
@ -218,7 +218,7 @@ int G2_IsSurfaceOff (const char *fileName, surfaceInfo_v &slist, const char *sur
for ( int i = 0 ; i < mod->mdxm->numSurfaces ; i++)
{
if (!stricmp(surfaceName, surface->name))
if (!Q_stricmp(surfaceName, surface->name))
{
return surface->flags;
}

2
CODE-mp/qcommon/GenericParser2.cpp
View file

@ -512,7 +512,7 @@ CGPGroup *CGPGroup::FindSubGroup(const char *name)
group = mSubGroups;
while(group)
{
if(!stricmp(name, group->GetName()))
if(!Q_stricmp(name, group->GetName()))
{
return(group);
}

2
CODE-mp/renderer/tr_model.cpp
View file

@ -398,7 +398,7 @@ static void RE_RegisterModels_DumpNonPure(void)
if (iInPak == -1 || iCheckSum != CachedModel.iPAKFileCheckSum)
{
if (stricmp(sDEFAULT_GLA_NAME ".gla" , psModelName)) // don't dump "*default.gla", that's program internal anyway
if (Q_stricmp(sDEFAULT_GLA_NAME ".gla" , psModelName)) // don't dump "*default.gla", that's program internal anyway
{
// either this is not from a PAK, or it's from a non-pure one, so ditch it...
//

2
CODE-mp/renderer/tr_shader.cpp
View file

@ -71,7 +71,7 @@ int R_FindHitMat(const char *fname)
// simple linear search, this should only be called during precache anyway
for (i=1; i<hitMatCount; i++)
{
if (!stricmp(hitMatReg[i].name, fname))
if (!Q_stricmp(hitMatReg[i].name, fname))
{
return i;
}

2
CODE-mp/unix/linux_glimp.cpp
View file

@ -1305,7 +1305,7 @@ void GLimp_Init( void )
void GLimp_EndFrame (void)
{
// don't flip if drawing to front buffer
if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
{
qglXSwapBuffers(dpy, win);
}

2
CODE-mp/win32/win_glimp.cpp
View file

@ -1324,7 +1324,7 @@ void GLimp_EndFrame (void)
// don't flip if drawing to front buffer
if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
{
SwapBuffers( glw_state.hDC );
}