BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/client/cdll_util.cpp

1318 lines
35 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Workfile: $
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include <stdarg.h>
#include "hud.h"
#include "itextmessage.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/itexture.h"
#include "materialsystem/imaterialsystem.h"
#include "imovehelper.h"
#include "checksum_crc.h"
#include "decals.h"
#include "iefx.h"
#include "view_scene.h"
#include "filesystem.h"
#include "model_types.h"
#include "engine/IEngineTrace.h"
#include "engine/ivmodelinfo.h"
#include "c_te_effect_dispatch.h"
#include <vgui_controls/Controls.h>
#include <vgui/ISurface.h>
#include <vgui/ILocalize.h>
#include "view.h"
#include "ixboxsystem.h"
#include "inputsystem/iinputsystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar localplayer_visionflags( "localplayer_visionflags", "0", FCVAR_DEVELOPMENTONLY );
//-----------------------------------------------------------------------------
// ConVars
//-----------------------------------------------------------------------------
#ifdef _DEBUG
ConVar r_FadeProps( "r_FadeProps", "1" );
#endif
bool g_MakingDevShots = false;
extern ConVar cl_leveloverview;
//-----------------------------------------------------------------------------
// Purpose: Performs a var args printf into a static return buffer
// Input : *format -
// ... -
// Output : char
//-----------------------------------------------------------------------------
char *VarArgs( const char *format, ... )
{
va_list argptr;
static char string[1024];
va_start (argptr, format);
Q_vsnprintf (string, sizeof( string ), format,argptr);
va_end (argptr);
return string;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the entity index corresponds to a player slot
// Input : index -
// Output : bool
//-----------------------------------------------------------------------------
bool IsPlayerIndex( int index )
{
return ( index >= 1 && index <= gpGlobals->maxClients ) ? true : false;
}
int GetLocalPlayerIndex( void )
{
C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();
if ( player )
return player->entindex();
else
return 0; // game not started yet
}
// NOTE: cache these because this gets executed hundreds of times per frame
static int g_nLocalPlayerVisionFlagsWeaponsCheck = 0;
static int g_nLocalPlayerVisionFlags = 0;
int GetLocalPlayerVisionFilterFlags( bool bWeaponsCheck /*= false */ )
{
return bWeaponsCheck ? g_nLocalPlayerVisionFlagsWeaponsCheck : g_nLocalPlayerVisionFlags;
}
void UpdateLocalPlayerVisionFlags()
{
g_nLocalPlayerVisionFlagsWeaponsCheck = 0;
g_nLocalPlayerVisionFlags = 0;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
g_nLocalPlayerVisionFlagsWeaponsCheck = pPlayer->GetVisionFilterFlags( true );
g_nLocalPlayerVisionFlags = pPlayer->GetVisionFilterFlags( false );
}
}
bool IsLocalPlayerUsingVisionFilterFlags( int nFlags, bool bWeaponsCheck /* = false */ )
{
int nLocalPlayerFlags = GetLocalPlayerVisionFilterFlags( bWeaponsCheck );
if ( !bWeaponsCheck )
{
// We can only modify the RJ flags with normal checks that won't take the forced kill cam flags that can happen in weapon checks
int nRJShaderFlags = nLocalPlayerFlags;
if ( nRJShaderFlags != 0 && GameRules() && !GameRules()->AllowMapVisionFilterShaders() )
{
nRJShaderFlags = 0;
}
if ( nRJShaderFlags != localplayer_visionflags.GetInt() )
{
localplayer_visionflags.SetValue( nRJShaderFlags );
}
}
return ( nLocalPlayerFlags & nFlags ) == nFlags;
}
bool IsLocalPlayerSpectator( void )
{
C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();
if ( player )
return player->IsObserver();
else
return false; // game not started yet
}
int GetSpectatorMode( void )
{
C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();
if ( player )
return player->GetObserverMode();
else
return OBS_MODE_NONE; // game not started yet
}
int GetSpectatorTarget( void )
{
C_BasePlayer * player = C_BasePlayer::GetLocalPlayer();
if ( player )
{
CBaseEntity * target = player->GetObserverTarget();
if ( target )
return target->entindex();
else
return 0;
}
else
{
return 0; // game not started yet
}
}
int GetLocalPlayerTeam( void )
{
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
return pPlayer->GetTeamNumber();
else
return TEAM_UNASSIGNED;
}
//-----------------------------------------------------------------------------
// Purpose: Convert angles to -180 t 180 range
// Input : angles -
//-----------------------------------------------------------------------------
void NormalizeAngles( QAngle& angles )
{
int i;
// Normalize angles to -180 to 180 range
for ( i = 0; i < 3; i++ )
{
if ( angles[i] > 180.0 )
{
angles[i] -= 360.0;
}
else if ( angles[i] < -180.0 )
{
angles[i] += 360.0;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Interpolate Euler angles using quaternions to avoid singularities
// Input : start -
// end -
// output -
// frac -
//-----------------------------------------------------------------------------
void InterpolateAngles( const QAngle& start, const QAngle& end, QAngle& output, float frac )
{
Quaternion src, dest;
// Convert to quaternions
AngleQuaternion( start, src );
AngleQuaternion( end, dest );
Quaternion result;
// Slerp
QuaternionSlerp( src, dest, frac, result );
// Convert to euler
QuaternionAngles( result, output );
}
//-----------------------------------------------------------------------------
// Purpose: Simple linear interpolation
// Input : frac -
// src -
// dest -
// output -
//-----------------------------------------------------------------------------
void InterpolateVector( float frac, const Vector& src, const Vector& dest, Vector& output )
{
int i;
for ( i = 0; i < 3; i++ )
{
output[ i ] = src[ i ] + frac * ( dest[ i ] - src[ i ] );
}
}
client_textmessage_t *TextMessageGet( const char *pName )
{
return engine->TextMessageGet( pName );
}
//-----------------------------------------------------------------------------
// Purpose: ScreenHeight returns the height of the screen, in pixels
// Output : int
//-----------------------------------------------------------------------------
int ScreenHeight( void )
{
int w, h;
GetHudSize( w, h );
return h;
}
//-----------------------------------------------------------------------------
// Purpose: ScreenWidth returns the width of the screen, in pixels
// Output : int
//-----------------------------------------------------------------------------
int ScreenWidth( void )
{
int w, h;
GetHudSize( w, h );
return w;
}
//-----------------------------------------------------------------------------
// Purpose: Return the difference between two angles
// Input : destAngle -
// srcAngle -
// Output : float
//-----------------------------------------------------------------------------
float UTIL_AngleDiff( float destAngle, float srcAngle )
{
float delta;
delta = destAngle - srcAngle;
if ( destAngle > srcAngle )
{
while ( delta >= 180 )
delta -= 360;
}
else
{
while ( delta <= -180 )
delta += 360;
}
return delta;
}
float UTIL_WaterLevel( const Vector &position, float minz, float maxz )
{
Vector midUp = position;
midUp.z = minz;
if ( !(UTIL_PointContents(midUp) & MASK_WATER) )
return minz;
midUp.z = maxz;
if ( UTIL_PointContents(midUp) & MASK_WATER )
return maxz;
float diff = maxz - minz;
while (diff > 1.0)
{
midUp.z = minz + diff/2.0;
if ( UTIL_PointContents(midUp) & MASK_WATER )
{
minz = midUp.z;
}
else
{
maxz = midUp.z;
}
diff = maxz - minz;
}
return midUp.z;
}
void UTIL_Bubbles( const Vector& mins, const Vector& maxs, int count )
{
Vector mid = (mins + maxs) * 0.5;
float flHeight = UTIL_WaterLevel( mid, mid.z, mid.z + 1024 );
flHeight = flHeight - mins.z;
CPASFilter filter( mid );
int bubbles = modelinfo->GetModelIndex( "sprites/bubble.vmt" );
te->Bubbles( filter, 0.0,
&mins, &maxs, flHeight, bubbles, count, 8.0 );
}
void UTIL_ScreenShake( const Vector &center, float amplitude, float frequency, float duration, float radius, ShakeCommand_t eCommand, bool bAirShake )
{
// Nothing for now
}
char TEXTURETYPE_Find( trace_t *ptr )
{
surfacedata_t *psurfaceData = physprops->GetSurfaceData( ptr->surface.surfaceProps );
return psurfaceData->game.material;
}
//-----------------------------------------------------------------------------
// Purpose: Make a tracer effect
//-----------------------------------------------------------------------------
void UTIL_Tracer( const Vector &vecStart, const Vector &vecEnd, int iEntIndex, int iAttachment, float flVelocity, bool bWhiz, char *pCustomTracerName )
{
CEffectData data;
data.m_vStart = vecStart;
data.m_vOrigin = vecEnd;
data.m_hEntity = ClientEntityList().EntIndexToHandle( iEntIndex );
data.m_flScale = flVelocity;
// Flags
if ( bWhiz )
{
data.m_fFlags |= TRACER_FLAG_WHIZ;
}
if ( iAttachment != TRACER_DONT_USE_ATTACHMENT )
{
data.m_fFlags |= TRACER_FLAG_USEATTACHMENT;
// Stomp the start, since it's not going to be used anyway
data.m_vStart[0] = iAttachment;
}
// Fire it off
if ( pCustomTracerName )
{
DispatchEffect( pCustomTracerName, data );
}
else
{
DispatchEffect( "Tracer", data );
}
}
//------------------------------------------------------------------------------
// Purpose : Creates both an decal and any associated impact effects (such
// as flecks) for the given iDamageType and the trace's end position
// Input :
// Output :
//------------------------------------------------------------------------------
void UTIL_ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
{
C_BaseEntity *pEntity = pTrace->m_pEnt;
// Is the entity valid, is the surface sky?
if ( !pEntity || (pTrace->surface.flags & SURF_SKY) )
return;
if (pTrace->fraction == 1.0)
return;
// don't decal nodraw surfaces
if ( pTrace->surface.flags & SURF_NODRAW )
return;
pEntity->ImpactTrace( pTrace, iDamageType, pCustomImpactName );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int UTIL_PrecacheDecal( const char *name, bool preload )
{
return effects->Draw_DecalIndexFromName( (char*)name );
}
extern short g_sModelIndexSmoke;
void UTIL_Smoke( const Vector &origin, const float scale, const float framerate )
{
CPVSFilter filter( origin );
te->Smoke( filter, 0.0f, &origin, g_sModelIndexSmoke, scale, framerate );
}
void UTIL_SetOrigin( C_BaseEntity *entity, const Vector &vecOrigin )
{
entity->SetLocalOrigin( vecOrigin );
}
//#define PRECACHE_OTHER_ONCE
// UNDONE: Do we need this to avoid doing too much of this? Measure startup times and see
#if PRECACHE_OTHER_ONCE
#include "utlsymbol.h"
class CPrecacheOtherList : public CAutoServerSystem
{
public:
virtual void LevelInitPreEntity();
virtual void LevelShutdownPostEntity();
bool AddOrMarkPrecached( const char *pClassname );
private:
CUtlSymbolTable m_list;
};
void CPrecacheOtherList::LevelInitPreEntity()
{
m_list.RemoveAll();
}
void CPrecacheOtherList::LevelShutdownPostEntity()
{
m_list.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose: mark or add
// Input : *pEntity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPrecacheOtherList::AddOrMarkPrecached( const char *pClassname )
{
CUtlSymbol sym = m_list.Find( pClassname );
if ( sym.IsValid() )
return false;
m_list.AddString( pClassname );
return true;
}
CPrecacheOtherList g_PrecacheOtherList;
#endif
void UTIL_PrecacheOther( const char *szClassname )
{
#if PRECACHE_OTHER_ONCE
// already done this one?, if not, mark as done
if ( !g_PrecacheOtherList.AddOrMarkPrecached( szClassname ) )
return;
#endif
// Client should only do this once entities are coming down from server!!!
// Assert( engine->IsConnected() );
C_BaseEntity *pEntity = CreateEntityByName( szClassname );
if ( !pEntity )
{
Warning( "NULL Ent in UTIL_PrecacheOther\n" );
return;
}
if (pEntity)
{
pEntity->Precache( );
}
// Bye bye
pEntity->Release();
}
static csurface_t g_NullSurface = { "**empty**", 0 };
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void UTIL_SetTrace(trace_t& trace, const Ray_t& ray, C_BaseEntity *ent, float fraction, int hitgroup, unsigned int contents, const Vector& normal, float intercept )
{
trace.startsolid = (fraction == 0.0f);
trace.fraction = fraction;
VectorCopy( ray.m_Start, trace.startpos );
VectorMA( ray.m_Start, fraction, ray.m_Delta, trace.endpos );
VectorCopy( normal, trace.plane.normal );
trace.plane.dist = intercept;
trace.m_pEnt = C_BaseEntity::Instance( ent );
trace.hitgroup = hitgroup;
trace.surface = g_NullSurface;
trace.contents = contents;
}
//-----------------------------------------------------------------------------
// Purpose: Get the x & y positions of a world position in screenspace
// Returns true if it's onscreen
//-----------------------------------------------------------------------------
bool GetVectorInScreenSpace( Vector pos, int& iX, int& iY, Vector *vecOffset )
{
Vector screen;
// Apply the offset, if one was specified
if ( vecOffset != NULL )
pos += *vecOffset;
// Transform to screen space
int iFacing = ScreenTransform( pos, screen );
iX = 0.5f * ( 1.0f + screen[0] ) * ScreenWidth();
iY = 0.5f * ( 1.0f - screen[1] ) * ScreenHeight();
// Make sure the player's facing it
if ( iFacing )
{
// We're actually facing away from the Target. Stomp the screen position.
iX = -640;
iY = -640;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Get the x & y positions of a world position in HUD space
// Returns true if it's onscreen
//-----------------------------------------------------------------------------
bool GetVectorInHudSpace( Vector pos, int& iX, int& iY, Vector *vecOffset )
{
Vector screen;
// Apply the offset, if one was specified
if ( vecOffset != NULL )
pos += *vecOffset;
// Transform to HUD space
int iFacing = HudTransform( pos, screen );
iX = 0.5f * ( 1.0f + screen[0] ) * ScreenWidth();
iY = 0.5f * ( 1.0f - screen[1] ) * ScreenHeight();
// Make sure the player's facing it
if ( iFacing )
{
// We're actually facing away from the Target. Stomp the screen position.
iX = -640;
iY = -640;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Get the x & y positions of an entity in screenspace
// Returns true if it's onscreen
//-----------------------------------------------------------------------------
bool GetTargetInScreenSpace( C_BaseEntity *pTargetEntity, int& iX, int& iY, Vector *vecOffset )
{
return GetVectorInScreenSpace( pTargetEntity->WorldSpaceCenter(), iX, iY, vecOffset );
}
//-----------------------------------------------------------------------------
// Purpose: Get the x & y positions of an entity in Vgui space
// Returns true if it's onscreen
//-----------------------------------------------------------------------------
bool GetTargetInHudSpace( C_BaseEntity *pTargetEntity, int& iX, int& iY, Vector *vecOffset )
{
return GetVectorInHudSpace( pTargetEntity->WorldSpaceCenter(), iX, iY, vecOffset );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *player -
// msg_dest -
// *msg_name -
// *param1 -
// *param2 -
// *param3 -
// *param4 -
//-----------------------------------------------------------------------------
void ClientPrint( C_BasePlayer *player, int msg_dest, const char *msg_name, const char *param1 /*= NULL*/, const char *param2 /*= NULL*/, const char *param3 /*= NULL*/, const char *param4 /*= NULL*/ )
{
}
//-----------------------------------------------------------------------------
// class CFlaggedEntitiesEnum
//-----------------------------------------------------------------------------
// enumerate entities that match a set of edict flags into a static array
class CFlaggedEntitiesEnum : public IPartitionEnumerator
{
public:
CFlaggedEntitiesEnum( C_BaseEntity **pList, int listMax, int flagMask );
// This gets called by the enumeration methods with each element
// that passes the test.
virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity );
int GetCount() { return m_count; }
bool AddToList( C_BaseEntity *pEntity );
private:
C_BaseEntity **m_pList;
int m_listMax;
int m_flagMask;
int m_count;
};
CFlaggedEntitiesEnum::CFlaggedEntitiesEnum( C_BaseEntity **pList, int listMax, int flagMask )
{
m_pList = pList;
m_listMax = listMax;
m_flagMask = flagMask;
m_count = 0;
}
bool CFlaggedEntitiesEnum::AddToList( C_BaseEntity *pEntity )
{
if ( m_count >= m_listMax )
return false;
m_pList[m_count] = pEntity;
m_count++;
return true;
}
IterationRetval_t CFlaggedEntitiesEnum::EnumElement( IHandleEntity *pHandleEntity )
{
IClientEntity *pClientEntity = cl_entitylist->GetClientEntityFromHandle( pHandleEntity->GetRefEHandle() );
C_BaseEntity *pEntity = pClientEntity ? pClientEntity->GetBaseEntity() : NULL;
if ( pEntity )
{
if ( m_flagMask && !(pEntity->GetFlags() & m_flagMask) ) // Does it meet the criteria?
return ITERATION_CONTINUE;
if ( !AddToList( pEntity ) )
return ITERATION_STOP;
}
return ITERATION_CONTINUE;
}
//-----------------------------------------------------------------------------
// Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted
// Input : **pList -
// listMax -
// &mins -
// &maxs -
// flagMask -
// Output : int
//-----------------------------------------------------------------------------
int UTIL_EntitiesInBox( C_BaseEntity **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask, int partitionMask )
{
CFlaggedEntitiesEnum boxEnum( pList, listMax, flagMask );
::partition->EnumerateElementsInBox( partitionMask, mins, maxs, false, &boxEnum );
return boxEnum.GetCount();
}
//-----------------------------------------------------------------------------
// Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted
// Input : **pList -
// listMax -
// &center -
// radius -
// flagMask -
// Output : int
//-----------------------------------------------------------------------------
int UTIL_EntitiesInSphere( C_BaseEntity **pList, int listMax, const Vector &center, float radius, int flagMask, int partitionMask )
{
CFlaggedEntitiesEnum sphereEnum( pList, listMax, flagMask );
::partition->EnumerateElementsInSphere( partitionMask, center, radius, false, &sphereEnum );
return sphereEnum.GetCount();
}
//-----------------------------------------------------------------------------
// Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted
// Input : **pList -
// listMax -
// &ray -
// flagMask -
// Output : int
//-----------------------------------------------------------------------------
int UTIL_EntitiesAlongRay( C_BaseEntity **pList, int listMax, const Ray_t &ray, int flagMask, int partitionMask )
{
CFlaggedEntitiesEnum rayEnum( pList, listMax, flagMask );
::partition->EnumerateElementsAlongRay( partitionMask, ray, false, &rayEnum );
return rayEnum.GetCount();
}
CEntitySphereQuery::CEntitySphereQuery( const Vector &center, float radius, int flagMask, int partitionMask )
{
m_listIndex = 0;
m_listCount = UTIL_EntitiesInSphere( m_pList, ARRAYSIZE(m_pList), center, radius, flagMask, partitionMask );
}
CBaseEntity *CEntitySphereQuery::GetCurrentEntity()
{
if ( m_listIndex < m_listCount )
return m_pList[m_listIndex];
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : font -
// *str -
// Output : int
//-----------------------------------------------------------------------------
int UTIL_ComputeStringWidth( vgui::HFont& font, const char *str )
{
float pixels = 0;
const char *p = str;
const char *pAfter = p + 1;
const char *pBefore = "\0";
while ( *p )
{
#if USE_GETKERNEDCHARWIDTH
float wide, abcA;
vgui::surface()->GetKernedCharWidth( font, *p, *pBefore, *pAfter, wide, abcA );
pixels += wide;
#else
pixels += vgui::surface()->GetCharacterWidth( font, *p );
#endif
pBefore = p;
p++;
if ( *p )
pAfter = p + 1;
else
pAfter = "\0";
}
return (int)ceil(pixels);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : font -
// *str -
// Output : int
//-----------------------------------------------------------------------------
int UTIL_ComputeStringWidth( vgui::HFont& font, const wchar_t *str )
{
float pixels = 0;
const wchar_t *p = str;
const wchar_t *pAfter = p + 1;
const wchar_t *pBefore = L"\0";
while ( *p )
{
#if USE_GETKERNEDCHARWIDTH
float wide, abcA;
vgui::surface()->GetKernedCharWidth( font, *p, *pBefore, *pAfter, wide, abcA );
pixels += wide;
#else
pixels += vgui::surface()->GetCharacterWidth( font, *p );
#endif
pBefore = p;
p++;
if ( *p )
pAfter = p + 1;
else
pAfter = L"\0";
}
return (int)ceil(pixels);
}
//-----------------------------------------------------------------------------
// Purpose: Scans player names
//Passes the player name to be checked in a KeyValues pointer
//with the keyname "name"
// - replaces '&' with '&&' so they will draw in the scoreboard
// - replaces '#' at the start of the name with '*'
//-----------------------------------------------------------------------------
void UTIL_MakeSafeName( const char *oldName, char *newName, int newNameBufSize )
{
Assert( newNameBufSize >= sizeof(newName[0]) );
int newpos = 0;
for( const char *p=oldName; *p != 0 && newpos < newNameBufSize-1; p++ )
{
//check for a '#' char at the beginning
if( p == oldName && *p == '#' )
{
newName[newpos] = '*';
newpos++;
}
else if( *p == '%' )
{
// remove % chars
newName[newpos] = '*';
newpos++;
}
else if( *p == '&' )
{
//insert another & after this one
if ( newpos+2 < newNameBufSize )
{
newName[newpos] = '&';
newName[newpos+1] = '&';
newpos+=2;
}
}
else
{
newName[newpos] = *p;
newpos++;
}
}
newName[newpos] = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Scans player names and replaces characters that vgui won't
// display properly
// Input : *oldName - player name to be fixed up
// Output : *char - static buffer with the safe name
//-----------------------------------------------------------------------------
const char * UTIL_SafeName( const char *oldName )
{
static char safeName[ MAX_PLAYER_NAME_LENGTH * 2 + 1 ];
UTIL_MakeSafeName( oldName, safeName, sizeof( safeName ) );
return safeName;
}
//-----------------------------------------------------------------------------
// Purpose: Looks up key bindings for commands and replaces them in string.
// %<commandname>% will get replaced with its bound control, e.g. %attack2%
// Input buffer sizes are in bytes rather than unicode character count
// for consistency with other APIs. If inbufsizebytes is 0 a NULL-terminated
// input buffer is assumed, or you can pass the size of the input buffer if
// not NULL-terminated.
//
// If actionset is other than GAME_ACTION_SET_NONE (the default), then a lookup is first
// attempted for a Steam Controller binding in the given action set. If none if found, fallback
// is to the usual keyboard binding path.
//-----------------------------------------------------------------------------
void UTIL_ReplaceKeyBindings( const wchar_t *inbuf, int inbufsizebytes, OUT_Z_BYTECAP(outbufsizebytes) wchar_t *outbuf, int outbufsizebytes, GameActionSet_t actionset )
{
Assert( outbufsizebytes >= sizeof(outbuf[0]) );
// copy to a new buf if there are vars
outbuf[0]=0;
if ( !inbuf || !inbuf[0] )
return;
int pos = 0;
const wchar_t *inbufend = NULL;
if ( inbufsizebytes > 0 )
{
inbufend = inbuf + ( inbufsizebytes / 2 );
}
while( inbuf != inbufend && *inbuf != 0 )
{
// check for variables
if ( *inbuf == '%' )
{
++inbuf;
const wchar_t *end = wcschr( inbuf, '%' );
if ( end && ( end != inbuf ) ) // make sure we handle %% in the string, which should be treated in the output as %
{
wchar_t token[64];
wcsncpy( token, inbuf, end - inbuf );
token[end - inbuf] = 0;
inbuf += end - inbuf;
// lookup key names
char binding[64];
g_pVGuiLocalize->ConvertUnicodeToANSI( token, binding, sizeof(binding) );
// Find a Steam Controller mapping, if an action set was specified.
const wchar_t* sc_origin = nullptr;
if ( actionset != GAME_ACTION_SET_NONE)
{
auto origin = g_pInputSystem->GetSteamControllerActionOrigin( *binding == '+' ? binding + 1 : binding, actionset );
if ( origin != k_EControllerActionOrigin_None )
{
sc_origin = g_pInputSystem->GetSteamControllerDescriptionForActionOrigin( origin );
}
}
// Find also the keyboard mapping
const char *key = engine->Key_LookupBinding( *binding == '+' ? binding + 1 : binding );
if ( !key )
{
key = IsX360() ? "" : "< not bound >";
}
//!! change some key names into better names
char friendlyName[64];
bool bAddBrackets = false;
if ( IsX360() )
{
if ( !key || !key[0] )
{
Q_snprintf( friendlyName, sizeof(friendlyName), "#GameUI_None" );
bAddBrackets = true;
}
else
{
Q_snprintf( friendlyName, sizeof(friendlyName), "#GameUI_KeyNames_%s", key );
}
}
else
{
Q_snprintf( friendlyName, sizeof(friendlyName), "%s", key );
}
Q_strupr( friendlyName );
const wchar_t* locName = nullptr;
// If we got a Steam Controller key description, use that, otherwise use the (possibly localized) key name
if ( sc_origin )
{
locName = sc_origin;
}
else
{
locName = g_pVGuiLocalize->Find( friendlyName );
}
if ( !locName || wcslen(locName) <= 0)
{
g_pVGuiLocalize->ConvertANSIToUnicode( friendlyName, token, sizeof(token) );
outbuf[pos] = '\0';
wcscat( outbuf, token );
pos += wcslen(token);
}
else
{
outbuf[pos] = '\0';
if ( bAddBrackets )
{
wcscat( outbuf, L"[" );
pos += 1;
}
wcscat( outbuf, locName );
pos += wcslen(locName);
if ( bAddBrackets )
{
wcscat( outbuf, L"]" );
pos += 1;
}
}
}
else
{
outbuf[pos] = *inbuf;
++pos;
}
}
else
{
outbuf[pos] = *inbuf;
++pos;
}
++inbuf;
}
outbuf[pos] = '\0';
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
// *pLength -
// Output : byte
//-----------------------------------------------------------------------------
byte *UTIL_LoadFileForMe( const char *filename, int *pLength )
{
byte *buffer;
FileHandle_t file;
file = filesystem->Open( filename, "rb", "GAME" );
if ( FILESYSTEM_INVALID_HANDLE == file )
{
if ( pLength ) *pLength = 0;
return NULL;
}
int size = filesystem->Size( file );
buffer = new byte[ size + 1 ];
if ( !buffer )
{
Warning( "UTIL_LoadFileForMe: Couldn't allocate buffer of size %i for file %s\n", size + 1, filename );
filesystem->Close( file );
return NULL;
}
filesystem->Read( buffer, size, file );
filesystem->Close( file );
// Ensure null terminator
buffer[ size ] =0;
if ( pLength )
{
*pLength = size;
}
return buffer;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *buffer -
//-----------------------------------------------------------------------------
void UTIL_FreeFile( byte *buffer )
{
delete[] buffer;
}
//-----------------------------------------------------------------------------
// Compute distance fade
//-----------------------------------------------------------------------------
static unsigned char ComputeDistanceFade( C_BaseEntity *pEntity, float flMinDist, float flMaxDist )
{
if ((flMinDist <= 0) && (flMaxDist <= 0))
return 255;
if( flMinDist > flMaxDist )
{
::V_swap( flMinDist, flMaxDist );
}
// If a negative value is provided for the min fade distance, then base it off the max.
if( flMinDist < 0 )
{
flMinDist = flMaxDist - 400;
if( flMinDist < 0 )
{
flMinDist = 0;
}
}
flMinDist *= flMinDist;
flMaxDist *= flMaxDist;
float flCurrentDistanceSq = CurrentViewOrigin().DistToSqr( pEntity->WorldSpaceCenter() );
C_BasePlayer *pLocal = C_BasePlayer::GetLocalPlayer();
if ( pLocal )
{
float flDistFactor = pLocal->GetFOVDistanceAdjustFactor();
flCurrentDistanceSq *= flDistFactor * flDistFactor;
}
// If I'm inside the minimum range than don't resort to alpha trickery
if ( flCurrentDistanceSq <= flMinDist )
return 255;
if ( flCurrentDistanceSq >= flMaxDist )
return 0;
// NOTE: Because of the if-checks above, flMinDist != flMinDist here
float flFalloffFactor = 255.0f / (flMaxDist - flMinDist);
int nAlpha = flFalloffFactor * (flMaxDist - flCurrentDistanceSq);
return clamp( nAlpha, 0, 255 );
}
//-----------------------------------------------------------------------------
// Compute fade amount
//-----------------------------------------------------------------------------
unsigned char UTIL_ComputeEntityFade( C_BaseEntity *pEntity, float flMinDist, float flMaxDist, float flFadeScale )
{
unsigned char nAlpha = 255;
// If we're taking devshots, don't fade props at all
if ( g_MakingDevShots || cl_leveloverview.GetFloat() > 0 )
return 255;
#ifdef _DEBUG
if ( r_FadeProps.GetBool() )
#endif
{
nAlpha = ComputeDistanceFade( pEntity, flMinDist, flMaxDist );
// NOTE: This computation for the center + radius is invalid!
// The center of the sphere is at the center of the OBB, which is not necessarily
// at the render origin. But it should be close enough.
Vector vecMins, vecMaxs;
pEntity->GetRenderBounds( vecMins, vecMaxs );
float flRadius = vecMins.DistTo( vecMaxs ) * 0.5f;
Vector vecAbsCenter;
if ( modelinfo->GetModelType( pEntity->GetModel() ) == mod_brush )
{
Vector vecRenderMins, vecRenderMaxs;
pEntity->GetRenderBoundsWorldspace( vecRenderMins, vecRenderMaxs );
VectorAdd( vecRenderMins, vecRenderMaxs, vecAbsCenter );
vecAbsCenter *= 0.5f;
}
else
{
vecAbsCenter = pEntity->GetRenderOrigin();
}
unsigned char nGlobalAlpha = IsXbox() ? 255 : modelinfo->ComputeLevelScreenFade( vecAbsCenter, flRadius, flFadeScale );
unsigned char nDistAlpha;
if ( !engine->IsLevelMainMenuBackground() )
{
nDistAlpha = modelinfo->ComputeViewScreenFade( vecAbsCenter, flRadius, flFadeScale );
}
else
{
nDistAlpha = 255;
}
if ( nDistAlpha < nGlobalAlpha )
{
nGlobalAlpha = nDistAlpha;
}
if ( nGlobalAlpha < nAlpha )
{
nAlpha = nGlobalAlpha;
}
}
return nAlpha;
}
//-----------------------------------------------------------------------------
// Purpose: Given a vector, clamps the scalar axes to MAX_COORD_FLOAT ranges from worldsize.h
// Input : *pVecPos -
//-----------------------------------------------------------------------------
void UTIL_BoundToWorldSize( Vector *pVecPos )
{
Assert( pVecPos );
for ( int i = 0; i < 3; ++i )
{
(*pVecPos)[ i ] = clamp( (*pVecPos)[ i ], MIN_COORD_FLOAT, MAX_COORD_FLOAT );
}
}
#ifdef _X360
#define MAP_KEY_FILE_DIR "cfg"
#else
#define MAP_KEY_FILE_DIR "media"
#endif
//-----------------------------------------------------------------------------
// Purpose: Returns the filename to count map loads in
//-----------------------------------------------------------------------------
bool UTIL_GetMapLoadCountFileName( const char *pszFilePrependName, char *pszBuffer, int iBuflen )
{
if ( IsX360() )
{
#ifdef _X360
if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )
return false;
#endif
}
if ( IsX360() )
{
Q_snprintf( pszBuffer, iBuflen, "%s:/%s", MAP_KEY_FILE_DIR, pszFilePrependName );
}
else
{
Q_snprintf( pszBuffer, iBuflen, "%s/%s", MAP_KEY_FILE_DIR, pszFilePrependName );
}
return true;
}
#ifdef TF_CLIENT_DLL
#define MAP_KEY_FILE "viewed.res"
#else
#define MAP_KEY_FILE "mapkeys.res"
#endif
void UTIL_IncrementMapKey( const char *pszCustomKey )
{
if ( !pszCustomKey )
return;
char szFilename[ _MAX_PATH ];
if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )
return;
int iCount = 1;
KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );
if ( kvMapLoadFile )
{
kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );
char mapname[MAX_MAP_NAME];
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );
Q_strlower( mapname );
// Increment existing, or add a new one
KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );
if ( pMapKey )
{
iCount = pMapKey->GetInt( pszCustomKey, 0 ) + 1;
pMapKey->SetInt( pszCustomKey, iCount );
}
else
{
KeyValues *pNewKey = new KeyValues( mapname );
if ( pNewKey )
{
pNewKey->SetString( pszCustomKey, "1" );
kvMapLoadFile->AddSubKey( pNewKey );
}
}
// Write it out
// force create this directory incase it doesn't exist
filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD");
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
kvMapLoadFile->RecursiveSaveToFile( buf, 0 );
g_pFullFileSystem->WriteFile( szFilename, "MOD", buf );
kvMapLoadFile->deleteThis();
}
if ( IsX360() )
{
#ifdef _X360
xboxsystem->FinishContainerWrites();
#endif
}
}
int UTIL_GetMapKeyCount( const char *pszCustomKey )
{
if ( !pszCustomKey )
return 0;
char szFilename[ _MAX_PATH ];
if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )
return 0;
int iCount = 0;
KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE );
if ( kvMapLoadFile )
{
// create an empty file if none exists
if ( !g_pFullFileSystem->FileExists( szFilename, "MOD" ) )
{
// force create this directory incase it doesn't exist
filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD");
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
g_pFullFileSystem->WriteFile( szFilename, "MOD", buf );
}
kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" );
char mapname[MAX_MAP_NAME];
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) );
Q_strlower( mapname );
KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname );
if ( pMapKey )
{
iCount = pMapKey->GetInt( pszCustomKey );
}
kvMapLoadFile->deleteThis();
}
return iCount;
}
bool UTIL_HasLoadedAnyMap()
{
char szFilename[ _MAX_PATH ];
if ( !UTIL_GetMapLoadCountFileName( MAP_KEY_FILE, szFilename, _MAX_PATH ) )
return false;
return g_pFullFileSystem->FileExists( szFilename, "MOD" );
}
Reference in New Issue View Git Blame Copy Permalink