Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

586 lines
19 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "c_baseentity.h"
#include "hud.h"
#include "hudelement.h"
#include "clientmode.h"
#include <vgui_controls/Panel.h>
#include <vgui/ISurface.h>
#include <vgui/ILocalize.h>
#include <vgui/IScheme.h>
#include <vgui_controls/AnimationController.h>
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "soundenvelope.h"
#include "convar.h"
#include "hud_closecaption.h"
#include "in_buttons.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define MAX_SPEAKER_NAME 256
#define MAX_COUNT_STRING 64
extern ConVar english;
extern ConVar closecaption;
class C_PointCommentaryNode;
CUtlVector< CHandle<C_PointCommentaryNode> > g_CommentaryNodes;
bool IsInCommentaryMode( void )
{
return (g_CommentaryNodes.Count() > 0);
}
static bool g_bTracingVsCommentaryNodes = false;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CHudCommentary : public CHudElement, public vgui::Panel
{
DECLARE_CLASS_SIMPLE( CHudCommentary, vgui::Panel );
public:
CHudCommentary( const char *name );
virtual void Init( void );
virtual void VidInit( void );
virtual void LevelInit( void ) { g_CommentaryNodes.Purge(); }
virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
void StartCommentary( C_PointCommentaryNode *pNode, char *pszSpeakers, int iNode, int iNodeMax, float flStartTime, float flEndTime );
void StopCommentary( void );
bool IsTheActiveNode( C_PointCommentaryNode *pNode ) { return (pNode == m_hActiveNode); }
// vgui overrides
virtual void Paint( void );
virtual bool ShouldDraw( void );
private:
CHandle<C_PointCommentaryNode> m_hActiveNode;
bool m_bShouldPaint;
float m_flStartTime;
float m_flEndTime;
wchar_t m_szSpeakers[MAX_SPEAKER_NAME];
wchar_t m_szCount[MAX_COUNT_STRING];
CMaterialReference m_matIcon;
bool m_bHiding;
// Painting
CPanelAnimationVarAliasType( int, m_iBarX, "bar_xpos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iBarY, "bar_ypos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iBarTall, "bar_height", "16", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iBarWide, "bar_width", "16", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iSpeakersX, "speaker_xpos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iSpeakersY, "speaker_ypos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iCountXFR, "count_xpos_from_right", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iCountY, "count_ypos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iIconX, "icon_xpos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iIconY, "icon_ypos", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iIconWide, "icon_width", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_iIconTall, "icon_height", "8", "proportional_int" );
CPanelAnimationVarAliasType( int, m_nIconTextureId, "icon_texture", "vgui/hud/icon_commentary", "textureid" );
CPanelAnimationVar( bool, m_bUseScriptBGColor, "use_script_bgcolor", "0" );
CPanelAnimationVar( Color, m_BackgroundColor, "BackgroundColor", "0 0 0 0" );
CPanelAnimationVar( Color, m_BGOverrideColor, "BackgroundOverrideColor", "Panel.BgColor" );
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class C_PointCommentaryNode : public C_BaseAnimating
{
DECLARE_CLASS( C_PointCommentaryNode, C_BaseAnimating );
public:
DECLARE_CLIENTCLASS();
DECLARE_DATADESC();
virtual void OnPreDataChanged( DataUpdateType_t type );
virtual void OnDataChanged( DataUpdateType_t type );
void OnRestore( void )
{
BaseClass::OnRestore();
if ( m_bActive )
{
StopLoopingSounds();
m_bRestartAfterRestore = true;
}
AddAndLockCommentaryHudGroup();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
virtual void SetDormant( bool bDormant )
{
if ( !IsDormant() && bDormant )
{
RemoveAndUnlockCommentaryHudGroup();
}
BaseClass::SetDormant( bDormant );
}
//-----------------------------------------------------------------------------
// Cleanup
//-----------------------------------------------------------------------------
void UpdateOnRemove( void )
{
RemoveAndUnlockCommentaryHudGroup();
StopLoopingSounds();
BaseClass::UpdateOnRemove();
}
void StopLoopingSounds( void );
virtual bool TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace );
void AddAndLockCommentaryHudGroup( void )
{
if ( !g_CommentaryNodes.Count() )
{
int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "commentary" );
gHUD.LockRenderGroup( iRenderGroup );
}
if ( g_CommentaryNodes.Find(this) == g_CommentaryNodes.InvalidIndex() )
{
g_CommentaryNodes.AddToTail( this );
}
}
void RemoveAndUnlockCommentaryHudGroup( void )
{
g_CommentaryNodes.FindAndRemove( this );
if ( !g_CommentaryNodes.Count() )
{
int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "commentary" );
gHUD.UnlockRenderGroup( iRenderGroup );
}
}
public:
// Data received from the server
bool m_bActive;
bool m_bWasActive;
float m_flStartTime;
char m_iszCommentaryFile[MAX_PATH];
char m_iszCommentaryFileNoHDR[MAX_PATH];
char m_iszSpeakers[MAX_SPEAKER_NAME];
int m_iNodeNumber;
int m_iNodeNumberMax;
CSoundPatch *m_sndCommentary;
EHANDLE m_hViewPosition;
bool m_bRestartAfterRestore;
};
IMPLEMENT_CLIENTCLASS_DT(C_PointCommentaryNode, DT_PointCommentaryNode, CPointCommentaryNode)
RecvPropBool( RECVINFO( m_bActive ) ),
RecvPropTime( RECVINFO( m_flStartTime ) ),
RecvPropString( RECVINFO(m_iszCommentaryFile) ),
RecvPropString( RECVINFO(m_iszCommentaryFileNoHDR) ),
RecvPropString( RECVINFO(m_iszSpeakers) ),
RecvPropInt( RECVINFO( m_iNodeNumber ) ),
RecvPropInt( RECVINFO( m_iNodeNumberMax ) ),
RecvPropEHandle( RECVINFO(m_hViewPosition) ),
END_RECV_TABLE()
BEGIN_DATADESC( C_PointCommentaryNode )
DEFINE_FIELD( m_bActive, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bWasActive, FIELD_BOOLEAN ),
DEFINE_SOUNDPATCH( m_sndCommentary ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_PointCommentaryNode::OnPreDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnPreDataChanged( updateType );
m_bWasActive = m_bActive;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_PointCommentaryNode::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_CREATED )
{
AddAndLockCommentaryHudGroup();
}
if ( m_bWasActive == m_bActive && !m_bRestartAfterRestore )
return;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( m_bActive && pPlayer )
{
// Use the HDR / Non-HDR version based on whether we're running HDR or not
char *pszCommentaryFile;
if ( g_pMaterialSystemHardwareConfig->GetHDRType() == HDR_TYPE_NONE && m_iszCommentaryFileNoHDR && m_iszCommentaryFileNoHDR[0] )
{
pszCommentaryFile = m_iszCommentaryFileNoHDR;
}
else
{
pszCommentaryFile = m_iszCommentaryFile;
}
if ( !pszCommentaryFile || !pszCommentaryFile[0] )
{
engine->ServerCmd( "commentary_finishnode\n" );
return;
}
EmitSound_t es;
es.m_nChannel = CHAN_STATIC;
es.m_pSoundName = pszCommentaryFile;
es.m_SoundLevel = SNDLVL_GUNFIRE;
es.m_nFlags = SND_SHOULDPAUSE;
CBaseEntity *pSoundEntity;
if ( m_hViewPosition )
{
pSoundEntity = m_hViewPosition;
}
else if ( render->GetViewEntity() )
{
pSoundEntity = cl_entitylist->GetEnt( render->GetViewEntity() );
es.m_SoundLevel = SNDLVL_NONE;
}
else
{
pSoundEntity = pPlayer;
}
CSingleUserRecipientFilter filter( pPlayer );
m_sndCommentary = (CSoundEnvelopeController::GetController()).SoundCreate( filter, pSoundEntity->entindex(), es );
if ( m_sndCommentary )
{
(CSoundEnvelopeController::GetController()).SoundSetCloseCaptionDuration( m_sndCommentary, -1 );
(CSoundEnvelopeController::GetController()).Play( m_sndCommentary, 1.0f, 100, m_flStartTime );
}
// Get the duration so we know when it finishes
float flDuration = enginesound->GetSoundDuration( STRING( CSoundEnvelopeController::GetController().SoundGetName( m_sndCommentary ) ) ) ;
CHudCloseCaption *pHudCloseCaption = (CHudCloseCaption *)GET_HUDELEMENT( CHudCloseCaption );
if ( pHudCloseCaption )
{
// This is where we play the commentary close caption (and lock the other captions out).
// Also, if close captions are off we force a caption in non-English
if ( closecaption.GetBool() || ( !closecaption.GetBool() && !english.GetBool() ) )
{
// Clear the close caption element in preparation
pHudCloseCaption->Reset();
// Process the commentary caption
pHudCloseCaption->ProcessCaptionDirect( pszCommentaryFile, flDuration );
// Find the close caption hud element & lock it
pHudCloseCaption->Lock();
}
}
// Tell the HUD element
CHudCommentary *pHudCommentary = (CHudCommentary *)GET_HUDELEMENT( CHudCommentary );
pHudCommentary->StartCommentary( this, m_iszSpeakers, m_iNodeNumber, m_iNodeNumberMax, m_flStartTime, m_flStartTime + flDuration );
}
else if ( m_bWasActive )
{
StopLoopingSounds();
CHudCommentary *pHudCommentary = (CHudCommentary *)GET_HUDELEMENT( CHudCommentary );
if ( pHudCommentary->IsTheActiveNode(this) )
{
pHudCommentary->StopCommentary();
}
}
m_bRestartAfterRestore = false;
}
//-----------------------------------------------------------------------------
// Purpose: Shut down the commentary
//-----------------------------------------------------------------------------
void C_PointCommentaryNode::StopLoopingSounds( void )
{
if ( m_sndCommentary != NULL )
{
(CSoundEnvelopeController::GetController()).SoundDestroy( m_sndCommentary );
m_sndCommentary = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: No client side trace collisions
//-----------------------------------------------------------------------------
bool C_PointCommentaryNode::TestCollision( const Ray_t &ray, unsigned int mask, trace_t& trace )
{
if ( !g_bTracingVsCommentaryNodes )
return false;
return BaseClass::TestCollision( ray, mask, trace );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool IsNodeUnderCrosshair( C_BasePlayer *pPlayer )
{
// See if the player's looking at a commentary node
trace_t tr;
Vector vecSrc = pPlayer->EyePosition();
Vector vecForward;
AngleVectors( pPlayer->EyeAngles(), &vecForward );
g_bTracingVsCommentaryNodes = true;
UTIL_TraceLine( vecSrc, vecSrc + vecForward * MAX_TRACE_LENGTH, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
g_bTracingVsCommentaryNodes = false;
if ( !tr.m_pEnt )
return false;
return dynamic_cast<C_PointCommentaryNode*>(tr.m_pEnt);
}
//===================================================================================================================
// COMMENTARY HUD ELEMENT
//===================================================================================================================
DECLARE_HUDELEMENT( CHudCommentary );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CHudCommentary::CHudCommentary( const char *name ) : vgui::Panel( NULL, "HudCommentary" ), CHudElement( name )
{
vgui::Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetPaintBorderEnabled( false );
SetHiddenBits( HIDEHUD_PLAYERDEAD );
m_hActiveNode = NULL;
m_bShouldPaint = true;
}
void CHudCommentary::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
if ( m_bUseScriptBGColor )
{
SetBgColor( m_BGOverrideColor );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudCommentary::Paint()
{
float flDuration = (m_flEndTime - m_flStartTime);
float flPercentage = clamp( ( gpGlobals->curtime - m_flStartTime ) / flDuration, 0.f, 1.f );
if ( !m_hActiveNode )
{
if ( !m_bHiding )
{
m_bHiding = true;
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HideCommentary" );
CHudCloseCaption *pHudCloseCaption = (CHudCloseCaption *)GET_HUDELEMENT( CHudCloseCaption );
if ( pHudCloseCaption )
{
pHudCloseCaption->Reset();
}
}
}
else
{
// Detect the end of the commentary
if ( flPercentage >= 1 && m_hActiveNode )
{
m_hActiveNode = NULL;
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HideCommentary" );
engine->ServerCmd( "commentary_finishnode\n" );
}
}
if ( !m_bShouldPaint )
return;
int x, y, wide, tall;
GetBounds( x, y, wide, tall );
int xOffset = m_iBarX;
int yOffset = m_iBarY;
// Find our fade based on our time shown
Color clr = Color( 255, 170, 0, GetAlpha() );
// Draw the progress bar
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawOutlinedRect( xOffset, yOffset, xOffset+m_iBarWide, yOffset+m_iBarTall );
vgui::surface()->DrawSetColor( clr );
vgui::surface()->DrawFilledRect( xOffset+2, yOffset+2, xOffset+(int)(flPercentage*m_iBarWide)-2, yOffset+m_iBarTall-2 );
// Draw the speaker names
// Get our scheme and font information
vgui::HScheme scheme = vgui::scheme()->GetScheme( "ClientScheme" );
vgui::HFont hFont = vgui::scheme()->GetIScheme(scheme)->GetFont( "CommentaryDefault" );
if ( !hFont )
{
hFont = vgui::scheme()->GetIScheme(scheme)->GetFont( "Default" );
}
vgui::surface()->DrawSetTextFont( hFont );
vgui::surface()->DrawSetTextColor( clr );
vgui::surface()->DrawSetTextPos( m_iSpeakersX, m_iSpeakersY );
vgui::surface()->DrawPrintText( m_szSpeakers, wcslen(m_szSpeakers) );
if ( COMMENTARY_BUTTONS & IN_ATTACK )
{
int iY = m_iBarY + m_iBarTall + YRES(4);
wchar_t wzFinal[512] = L"";
wchar_t *pszText = g_pVGuiLocalize->Find( "#Commentary_PrimaryAttack" );
if ( pszText )
{
UTIL_ReplaceKeyBindings( pszText, 0, wzFinal, sizeof( wzFinal ) );
vgui::surface()->DrawSetTextPos( m_iSpeakersX, iY );
vgui::surface()->DrawPrintText( wzFinal, wcslen(wzFinal) );
}
pszText = g_pVGuiLocalize->Find( "#Commentary_SecondaryAttack" );
if ( pszText )
{
int w, h;
UTIL_ReplaceKeyBindings( pszText, 0, wzFinal, sizeof( wzFinal ) );
vgui::surface()->GetTextSize( hFont, wzFinal, w, h );
vgui::surface()->DrawSetTextPos( m_iBarX + m_iBarWide - w, iY );
vgui::surface()->DrawPrintText( wzFinal, wcslen(wzFinal) );
}
}
// Draw the commentary count
// Determine our text size, and move that far in from the right hand size (plus the offset)
int iCountWide, iCountTall;
vgui::surface()->GetTextSize( hFont, m_szCount, iCountWide, iCountTall );
vgui::surface()->DrawSetTextPos( wide - m_iCountXFR - iCountWide, m_iCountY );
vgui::surface()->DrawPrintText( m_szCount, wcslen(m_szCount) );
// Draw the icon
vgui::surface()->DrawSetColor( Color(255,170,0,GetAlpha()) );
vgui::surface()->DrawSetTexture(m_nIconTextureId);
vgui::surface()->DrawTexturedRect( m_iIconX, m_iIconY, m_iIconWide, m_iIconTall );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHudCommentary::ShouldDraw()
{
return ( m_hActiveNode || GetAlpha() > 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudCommentary::Init( void )
{
m_matIcon.Init( "vgui/hud/icon_commentary", TEXTURE_GROUP_VGUI );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudCommentary::VidInit( void )
{
SetAlpha(0);
StopCommentary();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudCommentary::StartCommentary( C_PointCommentaryNode *pNode, char *pszSpeakers, int iNode, int iNodeMax, float flStartTime, float flEndTime )
{
if ( (flEndTime - flStartTime) <= 0 )
return;
m_hActiveNode = pNode;
m_flStartTime = flStartTime;
m_flEndTime = flEndTime;
m_bHiding = false;
g_pVGuiLocalize->ConvertANSIToUnicode( pszSpeakers, m_szSpeakers, sizeof(m_szSpeakers) );
// Don't draw the element itself if closecaptions are on (and captions are always on in non-english mode)
ConVarRef pCVar( "closecaption" );
if ( pCVar.IsValid() )
{
m_bShouldPaint = ( !pCVar.GetBool() && english.GetBool() );
}
else
{
m_bShouldPaint = true;
}
SetPaintBackgroundEnabled( m_bShouldPaint );
char sz[MAX_COUNT_STRING];
Q_snprintf( sz, sizeof(sz), "%d \\ %d", iNode, iNodeMax );
g_pVGuiLocalize->ConvertANSIToUnicode( sz, m_szCount, sizeof(m_szCount) );
// If the commentary just started, play the commentary fade in.
if ( fabs(flStartTime - gpGlobals->curtime) < 1.0 )
{
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ShowCommentary" );
}
else
{
// We're reloading a savegame that has an active commentary going in it. Don't fade in.
SetAlpha( 255 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudCommentary::StopCommentary( void )
{
m_hActiveNode = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CommentaryModeShouldSwallowInput( C_BasePlayer *pPlayer )
{
if ( !IsInCommentaryMode() )
return false;
if ( pPlayer->m_nButtons & COMMENTARY_BUTTONS )
{
// Always steal the secondary attack
if ( pPlayer->m_nButtons & IN_ATTACK2 )
return true;
// See if there's any nodes ahead of us.
if ( IsNodeUnderCrosshair( pPlayer ) )
return true;
}
return false;
}