|
|
//========= 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 ¢er, 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 -
// ¢er -
// radius -
// flagMask -
// Output : int
//-----------------------------------------------------------------------------
int UTIL_EntitiesInSphere( C_BaseEntity **pList, int listMax, const Vector ¢er, 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 ¢er, 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" ); }
|