diff options
Diffstat (limited to 'game/client/replay/vgui/replayperformanceeditor.cpp')
| -rw-r--r-- | game/client/replay/vgui/replayperformanceeditor.cpp | 2675 |
1 files changed, 2675 insertions, 0 deletions
diff --git a/game/client/replay/vgui/replayperformanceeditor.cpp b/game/client/replay/vgui/replayperformanceeditor.cpp new file mode 100644 index 0000000..be274cc --- /dev/null +++ b/game/client/replay/vgui/replayperformanceeditor.cpp @@ -0,0 +1,2675 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + + +#include "cbase.h" + +#if defined( REPLAY_ENABLED ) + +#include "replayperformanceeditor.h" +#include "replay/replay.h" +#include "replay/ireplayperformanceeditor.h" +#include "replay/ireplayperformancecontroller.h" +#include "replay/performance.h" +#include "ienginevgui.h" +#include "iclientmode.h" +#include "vgui_controls/ImagePanel.h" +#include "vgui_controls/TextImage.h" +#include "vgui_controls/Slider.h" +#include "vgui_controls/Menu.h" +#include "vgui/ILocalize.h" +#include "vgui/IImage.h" +#include "c_team.h" +#include "vgui_avatarimage.h" +#include "vgui/ISurface.h" +#include "vgui/IInput.h" +#include "replay/replaycamera.h" +#include "replay/ireplaymanager.h" +#include "replay/iclientreplaycontext.h" +#include "confirm_dialog.h" +#include "replayperformancesavedlg.h" +#include "replay/irecordingsessionmanager.h" +#include "achievementmgr.h" +#include "c_playerresource.h" +#include "replay/gamedefs.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include <tier0/memdbgon.h> + +extern CAchievementMgr g_AchievementMgrTF; + +//----------------------------------------------------------------------------- + +using namespace vgui; + +//----------------------------------------------------------------------------- + +extern IReplayPerformanceController *g_pReplayPerformanceController; + +//----------------------------------------------------------------------------- + +// Hack-y global bool to communicate when we are rewinding for map load screens. +// Order of operations issues preclude the use of engine->IsPlayingDemo(). +bool g_bIsReplayRewinding = false; + +//----------------------------------------------------------------------------- + +// TODO: Make these archive? Right now, the tips are reset every time the game starts +ConVar replay_perftip_count_enter( "replay_perftip_count_enter", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_HIDDEN, "", true, 0, false, 0 ); +ConVar replay_perftip_count_exit( "replay_perftip_count_exit", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_HIDDEN, "", true, 0, false, 0 ); +ConVar replay_perftip_count_freecam_enter( "replay_perftip_count_freecam_enter", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_HIDDEN, "", true, 0, false, 0 ); +ConVar replay_perftip_count_freecam_exit( "replay_perftip_count_freecam_exit", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_HIDDEN, "", true, 0, false, 0 ); +ConVar replay_perftip_count_freecam_exit2( "replay_perftip_count_freecam_exit2", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_HIDDEN, "", true, 0, false, 0 ); + +ConVar replay_editor_fov_mousewheel_multiplier( "replay_editor_fov_mousewheel_multiplier", "5", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "The multiplier on mousewheel input for adjusting camera FOV in the replay editor." ); +ConVar replay_editor_fov_mousewheel_invert( "replay_editor_fov_mousewheel_invert", "0", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Invert FOV zoom/unzoom on mousewheel in the replay editor." ); + +ConVar replay_replayeditor_rewindmsgcounter( "replay_replayeditor_rewindmsgcounter", "0", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_HIDDEN, "" ); + +//----------------------------------------------------------------------------- + +#define MAX_TIP_DISPLAYS 1 + +//----------------------------------------------------------------------------- + +#define TIMESCALE_MIN 0.01f +#define TIMESCALE_MAX 3.0f + +//----------------------------------------------------------------------------- + +#define SLIDER_RANGE_MAX 10000.0f + +//----------------------------------------------------------------------------- + +#define REPLAY_SOUND_DIALOG_POPUP "replay\\replaydialog_warn.wav" + +//----------------------------------------------------------------------------- + +static const char *gs_pCamNames[ NCAMS ] = +{ + "free", + "third", + "first", + "timescale", +}; + +static const char *gs_pBaseComponentNames[ NCAMS ] = +{ + "replay/replay_camera_%s%s", + "replay/replay_camera_%s%s", + "replay/replay_camera_%s%s", + "replay/replay_%s%s", +}; + +//----------------------------------------------------------------------------- + +void PlayDemo() +{ + engine->ClientCmd_Unrestricted( "demo_resume" ); +} + +void PauseDemo() +{ + engine->ClientCmd_Unrestricted( "demo_pause" ); +} + +//----------------------------------------------------------------------------- + +inline float SCurve( float t ) +{ + t = clamp( t, 0.0f, 1.0f ); + return t * t * (3 - 2*t); +} + +inline float CubicEaseIn( float t ) +{ + t = clamp( t, 0.0f, 1.0f ); + return t * t * t; +} + +inline float LerpScale( float flIn, float flInMin, float flInMax, float flOutMin, float flOutMax ) +{ + float flDenom = flInMax - flInMin; + if ( flDenom == 0.0f ) + return 0.0f; + + float t = clamp( ( flIn - flInMin ) / flDenom, 0.0f, 1.0f ); + return Lerp( t, flOutMin, flOutMax ); +} + +//----------------------------------------------------------------------------- + +void HighlightTipWords( Label *pLabel ) +{ + // Setup coloring - get # of words that should be highlighted + wchar_t *pwNumWords = g_pVGuiLocalize->Find( "#Replay_PerfTip_Highlight_NumWords" ); + if ( !pwNumWords ) + return; + + // Get the current label text + wchar_t wszLabelText[512]; + pLabel->GetText( wszLabelText, sizeof( wszLabelText ) ); + + pLabel->GetTextImage()->ClearColorChangeStream(); + pLabel->GetTextImage()->AddColorChange( pLabel->GetFgColor(), 0 ); + + int nNumWords = _wtoi( pwNumWords ); + for ( int i = 0; i < nNumWords; ++i ) + { + char szWordFindStr[64]; + V_snprintf( szWordFindStr, sizeof( szWordFindStr ), "#Replay_PerfTip_Highlight_Word%i", i ); + wchar_t *pwWord = g_pVGuiLocalize->Find( szWordFindStr ); + if ( !pwWord ) + continue; + + const int nWordLen = wcslen( pwWord ); + + // Find any instance of the word in the label text and highlight it in red + const wchar_t *p = wszLabelText; + do + { + const wchar_t *pInst = wcsstr( p, pwWord ); + if ( !pInst ) + break; + + // Highlight the text + int nStartPos = pInst - wszLabelText; + int nEndPos = nStartPos + nWordLen; + + // If start pos is non-zero, clear color changes + bool bChangeColor = true; + if ( nStartPos == 0 ) + { + pLabel->GetTextImage()->ClearColorChangeStream(); + } + else if ( iswalpha( wszLabelText[ nStartPos - 1 ] ) ) + { + // If this is not the beginning of the string, check the previous character. If it's + // not whitespace, etc, we found an instance of a keyword within another word. Skip. + bChangeColor = false; + } + + if ( bChangeColor ) + { + pLabel->GetTextImage()->AddColorChange( Color(200,80,60,255), nStartPos ); + pLabel->GetTextImage()->AddColorChange( pLabel->GetFgColor(), nEndPos ); + } + + p = pInst + nWordLen; + } while ( 1 ); + } +} + +//----------------------------------------------------------------------------- + +class CSavingDialog : public CGenericWaitingDialog +{ + DECLARE_CLASS_SIMPLE( CSavingDialog, CGenericWaitingDialog ); +public: + CSavingDialog( CReplayPerformanceEditorPanel *pEditorPanel ) + : CGenericWaitingDialog( pEditorPanel ) + { + m_pEditorPanel = pEditorPanel; + } + + virtual void OnTick() + { + BaseClass::OnTick(); + + if ( !g_pReplayPerformanceController ) + return; + + // Update async save + if ( g_pReplayPerformanceController->IsSaving() ) + { + g_pReplayPerformanceController->SaveThink(); + } + else + { + if ( m_pEditorPanel.Get() ) + { + m_pEditorPanel->OnSaveComplete(); + } + + Close(); + } + } + +private: + CConfirmDialog *m_pLoginDialog; + vgui::DHANDLE< CReplayPerformanceEditorPanel > m_pEditorPanel; +}; + +//----------------------------------------------------------------------------- + +class CReplayTipLabel : public Label +{ + DECLARE_CLASS_SIMPLE( CReplayTipLabel, Label ); +public: + CReplayTipLabel( Panel *pParent, const char *pName, const char *pText ) + : BaseClass( pParent, pName, pText ) + { + } + + virtual void ApplySchemeSettings( IScheme *pScheme ) + { + BaseClass::ApplySchemeSettings( pScheme ); + HighlightTipWords( this ); + } +}; + +DECLARE_BUILD_FACTORY_DEFAULT_TEXT( CReplayTipLabel, Label ); + +//----------------------------------------------------------------------------- + +class CPerformanceTip : public EditablePanel +{ + DECLARE_CLASS_SIMPLE( CPerformanceTip, EditablePanel ); +public: + static DHANDLE< CPerformanceTip > s_pTip; + + static CPerformanceTip *CreateInstance( const char *pText ) + { + if ( s_pTip ) + { + s_pTip->SetVisible( false ); + s_pTip->MarkForDeletion(); + s_pTip = NULL; + } + + s_pTip = SETUP_PANEL( new CPerformanceTip( pText ) ); + + return s_pTip; + } + + CPerformanceTip( const char *pText ) + : BaseClass( g_pClientMode->GetViewport(), "Tip" ), + m_flBornTime( gpGlobals->realtime ), + m_flAge( 0.0f ), + m_flShowDuration( 15.0f ) + { + m_pTextLabel = new CReplayTipLabel( this, "TextLabel", pText ); + } + + virtual void OnThink() + { + // Delete the panel if life exceeded + const float flEndTime = m_flBornTime + m_flShowDuration; + if ( gpGlobals->realtime >= flEndTime ) + { + SetVisible( false ); + MarkForDeletion(); + s_pTip = NULL; + return; + } + + SetVisible( true ); + + const float flFadeDuration = .4f; + float flAlpha; + + // Fade out? + if ( gpGlobals->realtime >= flEndTime - flFadeDuration ) + { + flAlpha = LerpScale( gpGlobals->realtime, flEndTime - flFadeDuration, flEndTime, 1.0f, 0.0f ); + } + + // Fade in? + else if ( gpGlobals->realtime <= m_flBornTime + flFadeDuration ) + { + flAlpha = LerpScale( gpGlobals->realtime, m_flBornTime, m_flBornTime + flFadeDuration, 0.0f, 1.0f ); + } + + // Otherwise, we must be in between fade in/fade out + else + { + flAlpha = 1.0f; + } + + SetAlpha( 255 * SCurve( flAlpha ) ); + } + + virtual void ApplySchemeSettings( IScheme *pScheme ) + { + BaseClass::ApplySchemeSettings( pScheme ); + + LoadControlSettings( "resource/ui/replayperformanceeditor/tip.res", "GAME" ); + + // Center relative to parent + const int nScreenW = ScreenWidth(); + const int nScreenH = ScreenHeight(); + int aContentSize[2]; + m_pTextLabel->GetContentSize( aContentSize[0], aContentSize[1] ); + const int nLabelHeight = aContentSize[1]; + SetBounds( + 0, + 3 * nScreenH / 4 - nLabelHeight / 2, + nScreenW, + nLabelHeight + 2 * m_nTopBottomMargin + ); + m_pTextLabel->SetBounds( + m_nLeftRightMarginWidth, + m_nTopBottomMargin, + nScreenW - 2 * m_nLeftRightMarginWidth, + nLabelHeight + ); + } + + static void Cleanup() + { + if ( s_pTip ) + { + s_pTip->MarkForDeletion(); + s_pTip = NULL; + } + } + + CPanelAnimationVarAliasType( int, m_nLeftRightMarginWidth, "left_right_margin", "0", "proportional_xpos" ); + CPanelAnimationVarAliasType( int, m_nTopBottomMargin , "top_bottom_margin", "0", "proportional_ypos" ); + + CReplayTipLabel *m_pTextLabel; + float m_flBornTime; + float m_flAge; + float m_flShowDuration; +}; + +DHANDLE< CPerformanceTip > CPerformanceTip::s_pTip; + +// Display the performance tip if we haven't already displayed it nMaxTimesToDisplay times or more +inline void DisplayPerformanceTip( const char *pText, ConVar* pCountCv = NULL, int nMaxTimesToDisplay = -1 ) +{ + // Already displayed too many times? Get out. + if ( pCountCv && nMaxTimesToDisplay >= 0 ) + { + int nCount = pCountCv->GetInt(); + if ( nCount >= nMaxTimesToDisplay ) + return; + + // Incremement count cvar + pCountCv->SetValue( nCount + 1 ); + } + + // Display the tip + CPerformanceTip::CreateInstance( pText ); +} + +//----------------------------------------------------------------------------- + +inline float GetPlaybackTime() +{ + CReplay *pPlayingReplay = g_pReplayManager->GetPlayingReplay(); + return gpGlobals->curtime - TICKS_TO_TIME( pPlayingReplay->m_nSpawnTick ); +} + +//----------------------------------------------------------------------------- + +class CPlayerCell : public CExImageButton +{ + DECLARE_CLASS_SIMPLE( CPlayerCell, CExImageButton ); +public: + CPlayerCell( Panel *pParent, const char *pName, int *pCurTargetPlayerIndex ) + : CExImageButton( pParent, pName, "" ), + m_iPlayerIndex( -1 ), + m_pCurTargetPlayerIndex( pCurTargetPlayerIndex ) + { + } + + virtual void ApplySchemeSettings( IScheme *pScheme ) + { + BaseClass::ApplySchemeSettings( pScheme ); + + GetImage()->SetImage( "" ); + SetFont( pScheme->GetFont( "ReplaySmall" ) ); + SetContentAlignment( Label::a_center ); + } + + MESSAGE_FUNC( DoClick, "PressButton" ) + { + ReplayCamera()->SetPrimaryTarget( m_iPlayerIndex ); + *m_pCurTargetPlayerIndex = m_iPlayerIndex; + + float flCurTime = GetPlaybackTime(); + + extern IReplayPerformanceController *g_pReplayPerformanceController; + g_pReplayPerformanceController->AddEvent_Camera_ChangePlayer( flCurTime, m_iPlayerIndex ); + } + + int m_iPlayerIndex; + int *m_pCurTargetPlayerIndex; // Allow the button to write current target in outer class when pressed +}; + +//----------------------------------------------------------------------------- + +/* +class CReplayEditorSlider : public Slider +{ + DECLARE_CLASS_SIMPLE( CReplayEditorSlider, Slider ); +public: + CReplayEditorSlider( Panel *pParent, const char *pName ) + : Slider( pParent, pName ) + { + } + + virtual void SetDefault( float flDefault ) { m_flDefault = flDefault; } + + ON_MESSAGE( Reset, OnReset ) + { + SetValue( + } + +private: + float m_flDefault; +}; +*/ + +//----------------------------------------------------------------------------- + +class CCameraOptionsPanel : public EditablePanel +{ + DECLARE_CLASS_SIMPLE( CCameraOptionsPanel, EditablePanel ); +public: + CCameraOptionsPanel( Panel *pParent, const char *pName, const char *pTitle ) + : EditablePanel( pParent, pName ), + m_bControlsAdded( false ) + { + m_pTitleLabel = new CExLabel( this, "TitleLabel", pTitle ); + + AddControlToLayout( m_pTitleLabel ); + } + + ~CCameraOptionsPanel() + { + m_lstSliderInfos.PurgeAndDeleteElements(); + } + + void AddControlToLayout( Panel *pControl ) + { + if ( pControl ) + { + m_lstControls.AddToTail( pControl ); + pControl->SetMouseInputEnabled( true ); + } + } + + // NOTE: Default value is assumed to be stored in flOut + void AddSliderToLayout( int nId, Slider *pSlider, const char *pLabelText, + float flMinValue, float flMaxValue, float &flOut ) + { + SliderInfo_t *pNewSliderInfo = new SliderInfo_t; + + pNewSliderInfo->m_nId = nId; + pNewSliderInfo->m_pSlider = pSlider; + pNewSliderInfo->m_flRange[ 0 ] = flMinValue; + pNewSliderInfo->m_flRange[ 1 ] = flMaxValue; + pNewSliderInfo->m_flDefault = flOut; + pNewSliderInfo->m_pValueOut = &flOut; + + m_lstSliderInfos.AddToTail( pNewSliderInfo ); + + AddControlToLayout( new EditablePanel( this, "Buffer" ) ); + AddControlToLayout( NewLabel( pLabelText ) ); + AddControlToLayout( NewSetDefaultButton( nId ) ); + AddControlToLayout( pSlider ); + + pSlider->AddActionSignalTarget( this ); + } + + void ResetSlider( int nId ) + { + const SliderInfo_t *pSliderInfo = FindSliderInfoFromId( nId ); + if ( !pSliderInfo ) + return; + + SetValue( pSliderInfo, pSliderInfo->m_flDefault ); + } + + void SetValue( int nId, float flValue ) + { + const SliderInfo_t *pSliderInfo = FindSliderInfoFromId( nId ); + if ( !pSliderInfo ) + return; + + SetValue( pSliderInfo, flValue ); + } + + virtual void ApplySchemeSettings( IScheme *pScheme ) + { + BaseClass::ApplySchemeSettings( pScheme ); + + // Setup border + SetBorder( pScheme->GetBorder( "ButtonBorder" ) ); + + HFont hFont = pScheme->GetFont( "ReplayBrowserSmallest", true ); + m_pTitleLabel->SetFont( hFont ); + m_pTitleLabel->SizeToContents(); + m_pTitleLabel->SetTall( YRES( 20 ) ); + m_pTitleLabel->SetColorStr( "235 235 235 255" ); + + if ( !m_bControlsAdded ) + { + const char *pResFile = GetResFile(); + if ( pResFile ) + { + LoadControlSettings( pResFile, "GAME" ); + } + + AddControls(); + m_bControlsAdded = true; + } + + FOR_EACH_LL( m_lstSliderInfos, it ) + { + SliderInfo_t *pInfo = m_lstSliderInfos[ it ]; + Slider *pSlider = pInfo->m_pSlider; + pSlider->SetRange( 0, SLIDER_RANGE_MAX ); + pSlider->SetNumTicks( 10 ); + float flDenom = fabs( pInfo->m_flRange[1] - pInfo->m_flRange[0] ); + pSlider->SetValue( SLIDER_RANGE_MAX * fabs( pInfo->m_flDefault - pInfo->m_flRange[0] ) / flDenom ); + } + } + + virtual void PerformLayout() + { + BaseClass::PerformLayout(); + + int nWidth = XRES( 140 ); + int nMargins[2] = { (int)XRES( 5 ), (int)YRES( 5 ) }; + int nVBuf = YRES( 0 ); + int nLastY = -1; + int nY = nMargins[1]; + Panel *pPrevPanel = NULL; + int nLastCtrlHeight = 0; + + FOR_EACH_LL( m_lstControls, i ) + { + Panel *pPanel = m_lstControls[ i ]; + if ( !pPanel->IsVisible() ) + continue; + + int aPos[2]; + pPanel->GetPos( aPos[0], aPos[1] ); + + if ( pPrevPanel && aPos[1] >= 0 ) + { + nY += pPrevPanel->GetTall() + nVBuf; + } + + // Gross hack to see if the control is a default button + if ( dynamic_cast< CExButton * >( pPanel ) ) + { + pPanel->SetWide( XRES( 36 ) ); + pPanel->SetPos( pPrevPanel ? ( GetWide() - nMargins[0] - pPanel->GetWide() ) : 0, nLastY ); + } + else + { + pPanel->SetWide( nWidth - 2 * nMargins[0] ); + pPanel->SetPos( nMargins[0], nY ); + } + + nLastY = nY; + pPrevPanel = pPanel; + nLastCtrlHeight = MAX( nLastCtrlHeight, pPanel->GetTall() ); + } + + SetSize( nWidth, nY + nLastCtrlHeight + 2 * YRES( 3 ) ); + } + + virtual void OnCommand( const char *pCommand ) + { + if ( !V_strnicmp( pCommand, "reset_", 6 ) ) + { + const int nSliderInfoId = atoi( pCommand + 6 ); + ResetSlider( nSliderInfoId ); + } + else + { + BaseClass::OnCommand( pCommand ); + } + } + + Label *NewLabel( const char *pText ) + { + Label *pLabel = new Label( this, "Label", pText ); + pLabel->SetTall( YRES( 9 ) ); + pLabel->SetPos( -1, 0 ); // Use default x and accumulated y + + // Set font + IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() ); + HFont hFont = pScheme->GetFont( "DefaultVerySmall", true ); + pLabel->SetFont( hFont ); + + return pLabel; + } + + CExButton *NewSetDefaultButton( int nSliderInfoId ) + { + CExButton *pButton = new CExButton( this, "DefaultButton", "#Replay_SetDefaultSetting" ); + pButton->SetTall( YRES( 11 ) ); + pButton->SetPos( XRES( 30 ), -1 ); // Set y to -1 so it will stay on the same line + pButton->SetContentAlignment( Label::a_center ); + CFmtStr fmtResetCommand( "reset_%i", nSliderInfoId ); + pButton->SetCommand( fmtResetCommand.Access() ); + pButton->AddActionSignalTarget( this ); + + // Set font + IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() ); + HFont hFont = pScheme->GetFont( "DefaultVerySmall", true ); + pButton->SetFont( hFont ); + + return pButton; + } + +protected: + MESSAGE_FUNC_PARAMS( OnSliderMoved, "SliderMoved", pParams ) + { + Panel *pSlider = (Panel *)pParams->GetPtr( "panel" ); + float flPercent = pParams->GetInt( "position" ) / SLIDER_RANGE_MAX; + + FOR_EACH_LL( m_lstSliderInfos, it ) + { + SliderInfo_t *pInfo = m_lstSliderInfos[ it ]; + if ( pSlider == pInfo->m_pSlider ) + { + *pInfo->m_pValueOut = Lerp( flPercent, pInfo->m_flRange[0], pInfo->m_flRange[1] ); + } + } + } + + virtual const char *GetResFile() { return NULL; } + + virtual void AddControls() + { + } + + struct SliderInfo_t + { + Slider *m_pSlider; + float m_flRange[2]; + float m_flDefault; + int m_nId; + float *m_pValueOut; + }; + + const SliderInfo_t *FindSliderInfoFromId( int nId ) + { + FOR_EACH_LL( m_lstSliderInfos, it ) + { + SliderInfo_t *pInfo = m_lstSliderInfos[ it ]; + if ( pInfo->m_nId == nId ) + return pInfo; + } + + AssertMsg( 0, "Should always find a slider here." ); + + return NULL; + } + + void SetValue( const SliderInfo_t *pSliderInfo, float flValue ) + { + if ( !pSliderInfo ) + { + AssertMsg( 0, "This should not happen." ); + return; + } + + // Calculate the range + const float flRange = fabs( pSliderInfo->m_flRange[1] - pSliderInfo->m_flRange[0] ); + AssertMsg( flRange > 0, "Bad slider range!" ); + + // Calculate the percentile based on the specified value and the range. + const float flPercent = fabs( flValue - pSliderInfo->m_flRange[0] ) / flRange; + pSliderInfo->m_pSlider->SetValue( flPercent * SLIDER_RANGE_MAX, true ); + } + + CUtlLinkedList< Panel * > m_lstControls; + CUtlLinkedList< SliderInfo_t *, int > m_lstSliderInfos; + CExLabel *m_pTitleLabel; + bool m_bControlsAdded; +}; + +//----------------------------------------------------------------------------- + +class CTimeScaleOptionsPanel : public CCameraOptionsPanel +{ + DECLARE_CLASS_SIMPLE( CTimeScaleOptionsPanel, CCameraOptionsPanel ); +public: + CTimeScaleOptionsPanel( Panel *pParent, float *pTimeScaleProxy ) + : BaseClass( pParent, "TimeScaleSettings", "#Replay_TimeScale" ), + m_pTimeScaleSlider( NULL ), + m_pTimeScaleProxy( pTimeScaleProxy ) + { + } + + virtual const char *GetResFile() + { + return "resource/ui/replayperformanceeditor/settings_timescale.res"; + } + + virtual void AddControls() + { + m_pTimeScaleSlider = dynamic_cast< Slider * >( FindChildByName( "TimeScaleSlider" ) ); + + AddSliderToLayout( SLIDER_TIMESCALE, m_pTimeScaleSlider, "#Replay_Scale", TIMESCALE_MIN, TIMESCALE_MAX, *m_pTimeScaleProxy ); + } + + enum FreeCamSliders_t + { + SLIDER_TIMESCALE, + }; + + Slider *m_pTimeScaleSlider; + float *m_pTimeScaleProxy; +}; + +//----------------------------------------------------------------------------- +class CCameraOptionsPanel_Free : public CCameraOptionsPanel +{ + DECLARE_CLASS_SIMPLE( CCameraOptionsPanel_Free, CCameraOptionsPanel ); +public: + CCameraOptionsPanel_Free( Panel *pParent ) + : BaseClass( pParent, "FreeCameraSettings", "#Replay_FreeCam" ), + m_pAccelSlider( NULL ), + m_pSpeedSlider( NULL ), + m_pFovSlider( NULL ), + m_pRotFilterSlider( NULL ), + m_pShakeSpeedSlider( NULL ), + m_pShakeAmountSlider( NULL ) + { + } + + virtual const char *GetResFile() + { + return "resource/ui/replayperformanceeditor/camsettings_free.res"; + } + + virtual void AddControls() + { + m_pAccelSlider = dynamic_cast< Slider * >( FindChildByName( "AccelSlider" ) ); + m_pSpeedSlider = dynamic_cast< Slider * >( FindChildByName( "SpeedSlider" ) ); + m_pFovSlider = dynamic_cast< Slider * >( FindChildByName( "FovSlider" ) ); + m_pRotFilterSlider = dynamic_cast< Slider * >( FindChildByName( "RotFilterSlider" ) ); + m_pShakeSpeedSlider = dynamic_cast< Slider * >( FindChildByName( "ShakeSpeedSlider" ) ); + m_pShakeAmountSlider = dynamic_cast< Slider * >( FindChildByName( "ShakeAmountSlider" ) ); + m_pShakeDirSlider = dynamic_cast< Slider * >( FindChildByName( "ShakeDirSlider" ) ); + + AddSliderToLayout( SLIDER_ACCEL, m_pAccelSlider, "#Replay_Accel", FREE_CAM_ACCEL_MIN, FREE_CAM_ACCEL_MAX, ReplayCamera()->m_flRoamingAccel ); + AddSliderToLayout( SLIDER_SPEED, m_pSpeedSlider, "#Replay_Speed", FREE_CAM_SPEED_MIN, FREE_CAM_SPEED_MAX, ReplayCamera()->m_flRoamingSpeed ); + AddSliderToLayout( SLIDER_FOV, m_pFovSlider, "#Replay_Fov", FREE_CAM_FOV_MIN, FREE_CAM_FOV_MAX, ReplayCamera()->m_flRoamingFov[1] ); + AddSliderToLayout( SLIDER_ROTFILTER, m_pRotFilterSlider, "#Replay_RotFilter", FREE_CAM_ROT_FILTER_MIN, FREE_CAM_ROT_FILTER_MAX, ReplayCamera()->m_flRoamingRotFilterFactor ); + AddSliderToLayout( SLIDER_SHAKE_SPEED, m_pShakeSpeedSlider, "#Replay_ShakeSpeed", FREE_CAM_SHAKE_SPEED_MIN, FREE_CAM_SHAKE_SPEED_MAX, ReplayCamera()->m_flRoamingShakeSpeed ); + AddSliderToLayout( SLIDER_SHAKE_AMOUNT, m_pShakeAmountSlider, "#Replay_ShakeAmount", FREE_CAM_SHAKE_AMOUNT_MIN, FREE_CAM_SHAKE_AMOUNT_MAX, ReplayCamera()->m_flRoamingShakeAmount ); + AddSliderToLayout( SLIDER_SHAKE_DIR, m_pShakeDirSlider, "#Replay_ShakeDir", FREE_CAM_SHAKE_DIR_MIN, FREE_CAM_SHAKE_DIR_MAX, ReplayCamera()->m_flRoamingShakeDir ); + } + + enum FreeCamSliders_t + { + SLIDER_ACCEL, + SLIDER_SPEED, + SLIDER_FOV, + SLIDER_ROTFILTER, + SLIDER_SHAKE_SPEED, + SLIDER_SHAKE_AMOUNT, + SLIDER_SHAKE_DIR, + }; + + Slider *m_pAccelSlider; + Slider *m_pSpeedSlider; + Slider *m_pFovSlider; + Slider *m_pRotFilterSlider; + Slider *m_pShakeSpeedSlider; + Slider *m_pShakeAmountSlider; + Slider *m_pShakeDirSlider; +}; + +//----------------------------------------------------------------------------- + +class CReplayButton : public CExImageButton +{ + DECLARE_CLASS_SIMPLE( CReplayButton, CExImageButton ); +public: + CReplayButton( Panel *pParent, const char *pName, const char *pText ) + : BaseClass( pParent, pName, pText ), + m_pTipText( NULL ) + { + } + + virtual void ApplySettings( KeyValues *pInResourceData ) + { + BaseClass::ApplySettings( pInResourceData ); + + const char *pTipName = pInResourceData->GetString( "tipname" ); + if ( pTipName && pTipName[0] ) + { + const wchar_t *pTipText = g_pVGuiLocalize->Find( pTipName ); + if ( pTipText && pTipText[0] ) + { + const int nTipLength = V_wcslen( pTipText ); + m_pTipText = new wchar_t[ nTipLength + 1 ]; + V_wcsncpy( m_pTipText, pTipText, sizeof(wchar_t) * ( nTipLength + 1 ) ); + m_pTipText[ nTipLength ] = L'\0'; + } + } + } + + virtual void OnCursorEntered() + { + BaseClass::OnCursorEntered(); + + CReplayPerformanceEditorPanel *pEditor = ReplayUI_GetPerformanceEditor(); + if ( pEditor && m_pTipText ) + { + pEditor->SetButtonTip( m_pTipText, this ); + pEditor->ShowButtonTip( true ); + } + } + + virtual void OnCursorExited() + { + BaseClass::OnCursorExited(); + + CReplayPerformanceEditorPanel *pEditor = ReplayUI_GetPerformanceEditor(); + if ( pEditor && m_pTipText ) + { + pEditor->ShowButtonTip( false ); + } + } + +private: + wchar_t *m_pTipText; +}; + +DECLARE_BUILD_FACTORY_DEFAULT_TEXT( CReplayButton, CExImageButton ); + +//----------------------------------------------------------------------------- + +#define MAX_FF_RAMP_TIME 8.0f // The amount of time until we ramp to max scale value. + +class CReplayEditorFastForwardButton : public CReplayButton +{ + DECLARE_CLASS_SIMPLE( CReplayEditorFastForwardButton, CReplayButton ); +public: + CReplayEditorFastForwardButton( Panel *pParent, const char *pName, const char *pText ) + : BaseClass( pParent, pName, pText ), + m_flPressTime( 0.0f ) + { + m_pHostTimescale = cvar->FindVar( "host_timescale" ); + AssertMsg( m_pHostTimescale, "host_timescale lookup failed!" ); + + ivgui()->AddTickSignal( GetVPanel(), 10 ); + } + + ~CReplayEditorFastForwardButton() + { + ivgui()->RemoveTickSignal( GetVPanel() ); + + // Avoid a non-1.0 host_timescale after replay edit, which can happen if + // the user is still holding downt he FF button at the end of the replay. + if ( m_pHostTimescale ) + { + m_pHostTimescale->SetValue( 1.0f ); + } + + // Resume demo playback so that any demo played later won't start paused. + PlayDemo(); + } + + virtual void OnMousePressed( MouseCode code ) + { + m_flPressTime = gpGlobals->realtime; + PlayDemo(); + + BaseClass::OnMousePressed( code ); + } + + virtual void OnMouseReleased( MouseCode code ) + { + m_flPressTime = 0.0f; + PauseDemo(); + + BaseClass::OnMouseReleased( code ); + } + + void OnTick() + { + float flScale; + + if ( m_flPressTime == 0.0f ) + { + flScale = 1.0f; + } + else + { + const float flElapsed = clamp( gpGlobals->realtime - m_flPressTime, 0.0f, MAX_FF_RAMP_TIME ); + const float t = CubicEaseIn( flElapsed / MAX_FF_RAMP_TIME ); + + // If a shift key is down... + if ( input()->IsKeyDown( KEY_LSHIFT ) || input()->IsKeyDown( KEY_RSHIFT ) ) + { + // ...slow down host_timescale. + flScale = .1f + .4f * t; + } + // If alt key down... + else if ( input()->IsKeyDown( KEY_LALT ) || input()->IsKeyDown( KEY_RALT ) ) + { + // ...FF very quickly, ramp from 5 to 10. + flScale = 5.0f + 5.0f * t; + } + else + { + // Otherwise, start at 1.5 and ramp upwards over time. + flScale = 1.5f + 3.5f * t; + } + } + + // Set host_timescale. + if ( m_pHostTimescale ) + { + m_pHostTimescale->SetValue( flScale ); + } + } + +private: + float m_flPressTime; + ConVar *m_pHostTimescale; +}; + +DECLARE_BUILD_FACTORY_DEFAULT_TEXT( CReplayEditorFastForwardButton, CExImageButton ); + +//----------------------------------------------------------------------------- + +class CRecLightPanel : public EditablePanel +{ + DECLARE_CLASS_SIMPLE( CRecLightPanel, vgui::EditablePanel ); +public: + CRecLightPanel( Panel *pParent ) + : EditablePanel( pParent, "RecLightPanel" ), + m_flPlayPauseTime( 0.0f ), + m_bPaused( false ), + m_bPerforming( false ) + { + m_pRecLights[ 0 ] = NULL; + m_pRecLights[ 1 ] = NULL; + m_pPlayPause[ 0 ] = NULL; + m_pPlayPause[ 1 ] = NULL; + } + + virtual void ApplySchemeSettings( IScheme *pScheme ) + { + BaseClass::ApplySchemeSettings( pScheme ); + + LoadControlSettings( "resource/ui/replayperformanceeditor/reclight.res", "GAME" ); + + m_pRecLights[ 0 ] = dynamic_cast< ImagePanel * >( FindChildByName( "RecLightOffImg" ) ); + m_pRecLights[ 1 ] = dynamic_cast< ImagePanel * >( FindChildByName( "RecLightOnImg" ) ); + + m_pPlayPause[ 0 ] = dynamic_cast< ImagePanel * >( FindChildByName( "PlayImg" ) ); + m_pPlayPause[ 1 ] = dynamic_cast< ImagePanel * >( FindChildByName( "PauseImg" ) ); + + m_pCameraFringe = dynamic_cast< ImagePanel *>( FindChildByName( "CameraFringe" ) ); + m_pCameraCrosshair = dynamic_cast< ImagePanel *>( FindChildByName( "CameraCrosshair" ) ); + } + + virtual void PerformLayout() + { + BaseClass::PerformLayout(); + + SetVisible( m_bPerforming ); + + const int nScreenWidth = ScreenWidth(); + const int nRecLightW = m_pRecLights[ 0 ]->GetWide(); + int nXPos = nScreenWidth - nRecLightW + XRES( 6 ); + int nYPos = -YRES( 8 ); + m_pRecLights[ 0 ]->SetPos( nXPos, nYPos ); + m_pRecLights[ 1 ]->SetPos( nXPos, nYPos ); + + const int nWidth = GetWide(); + const int nHeight = GetTall(); + + // Setup camera fringe height + if ( m_pCameraFringe ) + { + m_pCameraFringe->SetSize( nWidth, nHeight ); + m_pCameraFringe->InstallMouseHandler( this ); + } + + // Setup camera cross hair height + if ( m_pCameraCrosshair ) + { + int aImageSize[2]; + IImage *pImage = m_pCameraCrosshair->GetImage(); + pImage->GetSize( aImageSize[0], aImageSize[1] ); + + aImageSize[0] = m_pCameraCrosshair->GetWide(); + aImageSize[1] = m_pCameraCrosshair->GetTall(); + + const int nStartY = YRES( 13 ); + + m_pCameraCrosshair->SetBounds( + nStartY + ( nWidth - aImageSize[0] ) / 2, + nStartY + ( nHeight - aImageSize[1] ) / 2, + aImageSize[0] - 2 * nStartY, + aImageSize[1] - 2 * nStartY + ); + + m_pCameraCrosshair->InstallMouseHandler( this ); + } + } + + void UpdateBackgroundVisibility() + { + m_pCameraCrosshair->SetVisible( m_bPaused ); + m_pCameraFringe->SetVisible( m_bPaused ); + } + + virtual void OnThink() + { + const float flTime = gpGlobals->realtime; + bool bPauseAnimating = m_flPlayPauseTime > 0.0f && + flTime >= m_flPlayPauseTime && + flTime < ( m_flPlayPauseTime + m_flAnimTime ); + + // Setup light visibility + int nOnOff = fmod( flTime * 2.0f, 2.0f ); + bool bOnLightVisible = (bool)nOnOff; + bool bRecording = g_pReplayPerformanceController->IsRecording(); + m_pRecLights[ 0 ]->SetVisible( m_bPaused || ( bRecording && !bOnLightVisible ) ); + m_pRecLights[ 1 ]->SetVisible( bRecording && ( !m_bPaused && bOnLightVisible ) ); + + // Deal with fringe and crosshair vis + UpdateBackgroundVisibility(); + + int iPlayPauseActive = (int)m_bPaused; + + // Animate the pause icon + if ( bPauseAnimating ) + { + const float t = clamp( ( flTime - m_flPlayPauseTime ) / m_flAnimTime, 0.0f, 1.0f ); + const float s = SCurve( t ); + const int nSize = (int)Lerp( s, 60.0f, 60.0f * m_nAnimScale ); + int aCrossHairPos[2]; + m_pCameraCrosshair->GetPos( aCrossHairPos[0], aCrossHairPos[1] ); + const int nScreenXCenter = aCrossHairPos[0] + m_pCameraCrosshair->GetWide() / 2; + const int nScreenYCenter = aCrossHairPos[1] + m_pCameraCrosshair->GetTall() / 2; + + m_pPlayPause[ iPlayPauseActive ]->SetBounds( + nScreenXCenter - nSize / 2, + nScreenYCenter - nSize / 2, + nSize, + nSize + ); + + m_pPlayPause[ iPlayPauseActive ]->SetAlpha( (int)( MIN( 0.5f, 1.0f - s ) * 255) ); + } + + m_pPlayPause[ iPlayPauseActive ]->SetVisible( bPauseAnimating ); + m_pPlayPause[ !iPlayPauseActive ]->SetVisible( false ); + } + + void UpdatePauseState( bool bPaused ) + { + if ( bPaused == m_bPaused ) + return; + + m_bPaused = bPaused; + + m_flPlayPauseTime = gpGlobals->realtime; + } + + void SetPerforming( bool bPerforming ) + { + if ( bPerforming == m_bPerforming ) + return; + + m_bPerforming = bPerforming; + InvalidateLayout( true, false ); + } + + float m_flPlayPauseTime; + bool m_bPaused; + bool m_bPerforming; + ImagePanel *m_pPlayPause[2]; // 0=play, 1=pause + ImagePanel *m_pRecLights[2]; // 0=off, 1=on + ImagePanel *m_pCameraFringe; + ImagePanel *m_pCameraCrosshair; + + CPanelAnimationVar( int, m_nAnimScale, "anim_scale", "4" ); + CPanelAnimationVar( float, m_flAnimTime, "anim_time", "1.5" ); +}; + +//----------------------------------------------------------------------------- + +CReplayPerformanceEditorPanel::CReplayPerformanceEditorPanel( Panel *parent, ReplayHandle_t hReplay ) +: EditablePanel( parent, "ReplayPerformanceEditor" ), + m_hReplay( hReplay ), + m_flLastTime( -1 ), + m_nRedBlueLabelRightX( 0 ), + m_nBottomPanelStartY( 0 ), + m_nBottomPanelHeight( 0 ), + m_nLastRoundedTime( -1 ), + m_flSpaceDownStart( 0.0f ), + m_flOldFps( -1.0f ), + m_flLastTimeSpaceBarPressed( 0.0f ), + m_flActiveTimeInEditor( 0.0f ), + m_flTimeScaleProxy( 1.0f ), + m_iCameraSelection( CAM_FIRST ), + m_bMousePressed( false ), + m_bMouseDown( false ), + m_nMouseClickedOverCameraSettingsPanel( CAM_INVALID ), + m_bShownAtLeastOnce( false ), + m_bAchievementAwarded( false ), + m_pImageList( NULL ), + m_pCurTimeLabel( NULL ), + m_pTotalTimeLabel( NULL ), + m_pPlayerNameLabel( NULL ), + m_pMouseTargetPanel( NULL ), + m_pSlowMoButton( NULL ), + m_pRecLightPanel( NULL ), + m_pPlayerCellData( NULL ), + m_pBottom( NULL ), + m_pMenuButton( NULL ), + m_pMenu( NULL ), + m_pPlayerCellsPanel( NULL ), + m_pButtonTip( NULL ), + m_pSavingDlg( NULL ) +{ + V_memset( m_pCameraButtons, 0, sizeof( m_pCameraButtons ) ); + V_memset( m_pCtrlButtons, 0, sizeof( m_pCtrlButtons ) ); + V_memset( m_pCameraOptionsPanels, NULL, sizeof( m_pCameraOptionsPanels ) ); + + m_pCameraOptionsPanels[ CAM_FREE ] = new CCameraOptionsPanel_Free( this ); + m_pCameraOptionsPanels[ COMPONENT_TIMESCALE ] = new CTimeScaleOptionsPanel( this, &m_flTimeScaleProxy ); + + m_nRedBlueSigns[0] = -1; + m_nRedBlueSigns[1] = 1; + m_iCurPlayerTarget = -1; + m_bCurrentTargetNeedsVisibilityUpdate = false; + + m_pImageList = new ImageList( false ); + + SetParent( g_pClientMode->GetViewport() ); + + HScheme hScheme = scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme" ); + SetScheme( hScheme ); + + ivgui()->AddTickSignal( GetVPanel(), 16 ); // Roughly 60hz + + MakePopup( true ); + SetMouseInputEnabled( true ); + + // Create bottom + m_pBottom = new EditablePanel( this, "BottomPanel" ); + + // Add player cells + m_pPlayerCellsPanel = new EditablePanel( m_pBottom, "PlayerCellsPanel" ); + for ( int i = 0; i < 2; ++i ) + { + for ( int j = 0; j <= MAX_PLAYERS; ++j ) + { + m_pPlayerCells[i][j] = new CPlayerCell( m_pPlayerCellsPanel, "PlayerCell", &m_iCurPlayerTarget ); + m_pPlayerCells[i][j]->SetVisible( false ); + AddPanelKeyboardInputDisableList( m_pPlayerCells[i][j] ); + } + } + + // Create rec light panel + m_pRecLightPanel = SETUP_PANEL( new CRecLightPanel( g_pClientMode->GetViewport() ) ); + + // Display "enter performance mode" tip + DisplayPerformanceTip( "#Replay_PerfTip_EnterPerfMode", &replay_perftip_count_enter, MAX_TIP_DISPLAYS ); + + // Create menu + m_pMenu = new Menu( this, "Menu" ); + m_aMenuItemIds[ MENU_SAVE ] = m_pMenu->AddMenuItem( "#Replay_Save", "menu_save", this ); + m_aMenuItemIds[ MENU_SAVEAS ] = m_pMenu->AddMenuItem( "#Replay_SaveAs", "menu_saveas", this ); + m_pMenu->AddSeparator(); + m_aMenuItemIds[ MENU_EXIT ] = m_pMenu->AddMenuItem( "#Replay_Exit", "menu_exit", this ); + + m_pMenu->EnableUseMenuManager( false ); // The menu manager doesn't play nice with the menu button +} + +CReplayPerformanceEditorPanel::~CReplayPerformanceEditorPanel() +{ + m_pRecLightPanel->MarkForDeletion(); + m_pRecLightPanel = NULL; + + m_pButtonTip->MarkForDeletion(); + m_pButtonTip = NULL; + + g_bIsReplayRewinding = false; + + surface()->PlaySound( "replay\\performanceeditorclosed.wav" ); + + CPerformanceTip::Cleanup(); + + ClearPlayerCellData(); +} + +void CReplayPerformanceEditorPanel::ClearPlayerCellData() +{ + if ( m_pPlayerCellData ) + { + m_pPlayerCellData->deleteThis(); + m_pPlayerCellData = NULL; + } +} + +void CReplayPerformanceEditorPanel::AddPanelKeyboardInputDisableList( Panel *pPanel ) +{ + m_lstDisableKeyboardInputPanels.AddToTail( pPanel ); +} + +void CReplayPerformanceEditorPanel::ApplySchemeSettings( IScheme *pScheme ) +{ + BaseClass::ApplySchemeSettings( pScheme ); + + LoadControlSettings( "resource/ui/replayperformanceeditor/main.res", "GAME" ); + + m_lstDisableKeyboardInputPanels.RemoveAll(); + + int nParentWidth = GetParent()->GetWide(); + int nParentHeight = GetParent()->GetTall(); + + // Set size of this panel + SetSize( nParentWidth, nParentHeight ); + + // Layout bottom + if ( m_pBottom ) + { + m_nBottomPanelHeight = m_pBottom->GetTall(); // Get from .res + m_nBottomPanelStartY = nParentHeight - m_nBottomPanelHeight; + m_pBottom->SetBounds( 0, m_nBottomPanelStartY, nParentWidth, m_nBottomPanelHeight ); + } + + // Layout rec light panel - don't overlap bottom panel + m_pRecLightPanel->SetBounds( 0, 0, ScreenWidth(), m_nBottomPanelStartY ); + + // Setup camera buttons + const int nNumCameraButtons = NCAMS; + const char *pCameraButtonNames[nNumCameraButtons] = { "CameraFree", "CameraThird", "CameraFirst", "TimeScaleButton" }; + int nCurButtonX = nParentWidth - m_nRightMarginWidth; + int nLeftmostCameraButtonX = 0; + for ( int i = 0; i < nNumCameraButtons; ++i ) + { + m_pCameraButtons[i] = dynamic_cast< CExImageButton * >( FindChildByName( pCameraButtonNames[ i ] ) ); + if ( m_pCameraButtons[i] ) + { + CExImageButton *pCurButton = m_pCameraButtons[ i ]; + if ( !pCurButton ) + continue; + + nCurButtonX -= pCurButton->GetWide(); + + int nX, nY; + pCurButton->GetPos( nX, nY ); + pCurButton->SetPos( nCurButtonX, nY ); + + pCurButton->SetParent( m_pBottom ); + pCurButton->AddActionSignalTarget( this ); + +#if !defined( TF_CLIENT_DLL ) + pCurButton->SetPaintBorderEnabled( false ); +#endif + + AddPanelKeyboardInputDisableList( pCurButton ); + } + } + nLeftmostCameraButtonX = nCurButtonX; + + static const char *s_pControlButtonNames[NUM_CTRLBUTTONS] = { + "InButton", "GotoBeginningButton", "RewindButton", + "PlayButton", + "FastForwardButton", "GotoEndButton", "OutButton" + }; + for ( int i = 0; i < NUM_CTRLBUTTONS; ++i ) + { + CExImageButton *pCurButton = dynamic_cast< CExImageButton * >( FindChildByName( s_pControlButtonNames[ i ] ) ); Assert( pCurButton ); + if ( !pCurButton ) + continue; + + pCurButton->SetParent( m_pBottom ); + pCurButton->AddActionSignalTarget( this ); + + AddPanelKeyboardInputDisableList( pCurButton ); + +#if !defined( TF_CLIENT_DLL ) + pCurButton->SetPaintBorderEnabled( false ); +#endif + + m_pCtrlButtons[ i ] = pCurButton; + } + + // If the performance in tick is set, highlight the in point button + { + CReplayPerformance *pSavedPerformance = GetSavedPerformance(); + m_pCtrlButtons[ CTRLBUTTON_IN ]->SetSelected( pSavedPerformance && pSavedPerformance->HasInTick() ); + m_pCtrlButtons[ CTRLBUTTON_OUT ]->SetSelected( pSavedPerformance && pSavedPerformance->HasOutTick() ); + } + + // Select first-person camera by default. + UpdateCameraSelectionPosition( CAM_FIRST ); + + // Position time label + m_pCurTimeLabel = dynamic_cast< CExLabel * >( FindChildByName( "CurTimeLabel" ) ); + m_pTotalTimeLabel = dynamic_cast< CExLabel * >( FindChildByName( "TotalTimeLabel" ) ); + + m_pCurTimeLabel->SetParent( m_pBottom ); + m_pTotalTimeLabel->SetParent( m_pBottom ); + + // Get player name label + m_pPlayerNameLabel = dynamic_cast< CExLabel * >( FindChildByName( "PlayerNameLabel" ) ); + + // Get mouse target panel + m_pMouseTargetPanel = dynamic_cast< EditablePanel * >( FindChildByName( "MouseTargetPanel" ) ); + + for ( int i = 0; i < 2; ++i ) + { + for ( int j = 0; j <= MAX_PLAYERS; ++j ) + { + m_pPlayerCells[i][j]->SetMouseInputEnabled( true ); + } + } + + // Get menu button + m_pMenuButton = dynamic_cast< CExImageButton * >( FindChildByName( "MenuButton" ) ); + AddPanelKeyboardInputDisableList( m_pMenuButton ); + m_pMenuButton->SetMouseInputEnabled( true ); +#if !defined( TF_CLIENT_DLL ) + m_pMenuButton->SetPaintBorderEnabled( false ); +#endif + + // Get button tip + m_pButtonTip = dynamic_cast< CReplayTipLabel * >( FindChildByName( "ButtonTip" ) ); + m_pButtonTip->SetParent( g_pClientMode->GetViewport() ); +} + +static void Replay_GotoTick( bool bConfirmed, void *pContext ) +{ + if ( bConfirmed ) + { + int nGotoTick = (int)pContext; + CFmtStr fmtCmd( "demo_gototick %i\ndemo_pause\n", nGotoTick ); + engine->ClientCmd_Unrestricted( fmtCmd.Access() ); + } +} + +void CReplayPerformanceEditorPanel::OnSliderMoved( KeyValues *pParams ) +{ +} + +void CReplayPerformanceEditorPanel::OnInGameMouseWheelEvent( int nDelta ) +{ + HandleMouseWheel( nDelta ); +} + +void CReplayPerformanceEditorPanel::HandleMouseWheel( int nDelta ) +{ + if ( ReplayCamera()->GetMode() == OBS_MODE_ROAMING ) + { + // Invert mousewheel input if necessary + if ( replay_editor_fov_mousewheel_invert.GetBool() ) + { + nDelta *= -1; + } + + float &flFov = ReplayCamera()->m_flRoamingFov[1]; + flFov = clamp( flFov - nDelta * replay_editor_fov_mousewheel_multiplier.GetFloat(), FREE_CAM_FOV_MIN, FREE_CAM_FOV_MAX ); + + // Update FOV slider in free camera settings + CCameraOptionsPanel_Free *pFreeCamOptions = static_cast< CCameraOptionsPanel_Free * >( m_pCameraOptionsPanels[ CAM_FREE ] ); + pFreeCamOptions->m_pFovSlider->SetValue( flFov - FREE_CAM_FOV_MIN, false ); + } +} + +void CReplayPerformanceEditorPanel::ApplySettings( KeyValues *pInResourceData ) +{ + BaseClass::ApplySettings( pInResourceData ); + + ClearPlayerCellData(); + + KeyValues *pPlayerCellData = pInResourceData->FindKey( "PlayerCell" ); + if ( pPlayerCellData ) + { + m_pPlayerCellData = new KeyValues( "PlayerCell" ); + pPlayerCellData->CopySubkeys( m_pPlayerCellData ); + } +} + +CameraMode_t CReplayPerformanceEditorPanel::IsMouseOverActiveCameraOptionsPanel( int nMouseX, int nMouseY ) +{ + // In one of the camera options panels? + for ( int i = 0; i < NCAMS; ++i ) + { + CCameraOptionsPanel *pCurPanel = m_pCameraOptionsPanels[ i ]; + if ( pCurPanel && pCurPanel->IsVisible() && pCurPanel->IsWithin( nMouseX, nMouseY ) ) + return (CameraMode_t)i; + } + + return CAM_INVALID; +} + +void CReplayPerformanceEditorPanel::OnMouseWheeled( int nDelta ) +{ + HandleMouseWheel( nDelta ); +} + +void CReplayPerformanceEditorPanel::OnTick() +{ + BaseClass::OnTick(); + +// engine->Con_NPrintf( 0, "timescale: %f", g_pReplayPerformanceController->GetPlaybackTimeScale() ); + + C_ReplayCamera *pCamera = ReplayCamera(); + if ( !pCamera ) + return; + + // Calc elapsed time + float flElapsed = gpGlobals->realtime - m_flLastTime; + m_flLastTime = gpGlobals->realtime; + + // If this is the first time we're running and camera is valid, get primary target + if ( m_iCurPlayerTarget < 0 ) + { + m_iCurPlayerTarget = pCamera->GetPrimaryTargetIndex(); + } + + // NOTE: Third-person is not "controllable" yet + int nCameraMode = pCamera->GetMode(); + bool bInAControllableCameraMode = nCameraMode == OBS_MODE_ROAMING || nCameraMode == OBS_MODE_CHASE; + + // Get mouse cursor pos + int nMouseX, nMouseY; + input()->GetCursorPos( nMouseX, nMouseY ); + + // Toggle in and out of camera control if appropriate + // Mouse pressed? + bool bMouseDown = input()->IsMouseDown( MOUSE_LEFT ); + m_bMousePressed = bMouseDown && !m_bMouseDown; + m_bMouseDown = bMouseDown; + + // Reset this flag if mouse is no longer down + if ( !m_bMouseDown ) + { + m_nMouseClickedOverCameraSettingsPanel = CAM_INVALID; + } + + bool bNoDialogsUp = TFModalStack()->IsEmpty(); + bool bMouseCursorOverPerfEditor = nMouseY >= m_nBottomPanelStartY; + bool bMouseOverMenuButton = m_pMenuButton->IsWithin( nMouseX, nMouseY ); + bool bMouseOverMenu = m_pMenu->IsWithin( nMouseX, nMouseY ); + bool bRecording = g_pReplayPerformanceController->IsRecording(); + if ( IsVisible() && m_bMousePressed ) + { + CameraMode_t nActiveOptionsPanel = IsMouseOverActiveCameraOptionsPanel( nMouseX, nMouseY ); + if ( nActiveOptionsPanel != CAM_INVALID ) + { + m_nMouseClickedOverCameraSettingsPanel = nActiveOptionsPanel; + } + else if ( m_pMenu->IsVisible() && !m_pMenu->IsWithin( nMouseX, nMouseY ) ) + { + ToggleMenu(); + } + else if ( bInAControllableCameraMode && !bMouseCursorOverPerfEditor && !bMouseOverMenuButton && + !bMouseOverMenu && bNoDialogsUp ) + { + if ( bRecording ) + { + bool bMouseInputEnabled = IsMouseInputEnabled(); + + // Already in a controllable camera mode? + if ( bMouseInputEnabled ) + { + DisplayPerformanceTip( "#Replay_PerfTip_ExitFreeCam", &replay_perftip_count_freecam_exit, MAX_TIP_DISPLAYS ); + surface()->PlaySound( "replay\\cameracontrolmodeentered.wav" ); + } + else + { + DisplayPerformanceTip( "#Replay_PerfTip_EnterFreeCam", &replay_perftip_count_freecam_enter, MAX_TIP_DISPLAYS ); + surface()->PlaySound( "replay\\cameracontrolmodeexited.wav" ); + } + + SetMouseInputEnabled( !bMouseInputEnabled ); + } + else + { + // Play an error sound + surface()->PlaySound( "replay\\cameracontrolerror.wav" ); + } + } + } + + // Show panel if space key bar is down + bool bSpaceDown = bNoDialogsUp && !enginevgui->IsGameUIVisible() && input()->IsKeyDown( KEY_SPACE ); + m_bSpacePressed = bSpaceDown && !m_bSpaceDown; + m_bSpaceDown = bSpaceDown; + + // Modify visibility? + bool bShow = IsVisible(); + if ( m_bSpacePressed ) + { + bShow = !IsVisible(); + } + + // Set visibility? + if ( IsVisible() != bShow ) + { + ShowPanel( bShow ); + m_bShownAtLeastOnce = true; + + // For achievements: + Achievements_OnSpaceBarPressed(); + } + + // Factor in host_timescale. + float flScaledElapsed = flElapsed; + ConVarRef host_timescale( "host_timescale" ); + if ( host_timescale.GetFloat() > 0 ) + { + flScaledElapsed *= host_timescale.GetFloat(); + } + + // Do FOV smoothing + ReplayCamera()->SmoothFov( flScaledElapsed ); + + // Don't do any more processing if not needed + if ( !m_bShownAtLeastOnce ) + return; + + // Update time text if necessary + UpdateTimeLabels(); + + // Make all player cells invisible + int nTeamCounts[2] = {0,0}; + int nCurTeam = 0; + for ( int i = 0; i < 2; ++i ) + for ( int j = 0; j <= MAX_PLAYERS; ++j ) + { + m_pPlayerCells[i][j]->SetVisible( false ); + } + + int iMouseOverPlayerIndex = -1; + CPlayerCell *pMouseOverCell = NULL; + + // Update player cells + bool bLayoutPlayerCells = true; // TODO: only layout when necessary + C_ReplayGame_PlayerResource_t *pGamePlayerResource = dynamic_cast< C_ReplayGame_PlayerResource_t * >( g_PR ); + for ( int iPlayer = 1; iPlayer <= MAX_PLAYERS; ++iPlayer ) + { + IGameResources *pGR = GameResources(); + + if ( !pGR || !pGR->IsConnected( iPlayer ) ) + continue; + + // Which team? + int iTeam = pGR->GetTeam( iPlayer ); + switch ( iTeam ) + { + case REPLAY_TEAM_TEAM0: + ++nTeamCounts[0]; + nCurTeam = 0; + break; + case REPLAY_TEAM_TEAM1: + ++nTeamCounts[1]; + nCurTeam = 1; + break; + default: + nCurTeam = -1; + break; + } + + if ( nCurTeam < 0 ) + continue; + +#if !defined( CSTRIKE_DLL ) + int iPlayerClass = pGamePlayerResource->GetPlayerClass( iPlayer ); + if ( iPlayerClass == REPLAY_CLASS_UNDEFINED ) + continue; +#endif + + int nCurTeamCount = nTeamCounts[ nCurTeam ]; + CPlayerCell* pCell = m_pPlayerCells[ nCurTeam ][ nCurTeamCount-1 ]; + + // Cache the player index + pCell->m_iPlayerIndex = iPlayer; + + // Make visible + pCell->SetVisible( true ); + + // Show leaderboard icon +#if defined( TF_CLIENT_DLL ) + char szClassImg[64]; + extern const char *g_aPlayerClassNames_NonLocalized[ REPLAY_NUM_CLASSES ]; + char const *pClassName = iPlayerClass == TF_CLASS_DEMOMAN + ? "demo" + : g_aPlayerClassNames_NonLocalized[ iPlayerClass ]; + V_snprintf( szClassImg, sizeof( szClassImg ), "../HUD/leaderboard_class_%s", pClassName ); + + // Show dead icon instead? + if ( !pGamePlayerResource->IsAlive( iPlayer ) ) + { + V_strcat( szClassImg, "_d", sizeof( szClassImg ) ); + } + + IImage *pImage = scheme()->GetImage( szClassImg, true ); + if ( pImage ) + { + pImage->SetSize( 32, 32 ); + pCell->GetImage()->SetImage( pImage ); + } + +#elif defined( CSTRIKE_DLL ) + // TODO - create and use class icons + char szText[16]; + V_snprintf( szText, sizeof( szText ), "%i", nTeamCounts[ nCurTeam ] ); + pCell->SetText( szText ); +#endif + + // Display player name if mouse is over the current cell + if ( pCell->IsWithin( nMouseX, nMouseY ) ) + { + iMouseOverPlayerIndex = iPlayer; + pMouseOverCell = pCell; + } + } + + // Check to see if we're hovering over a camera-mode, and if so, display its options panel if it has one + if ( bRecording ) + { + for ( int i = 0; i < NCAMS; ++i ) + { + CCameraOptionsPanel *pCurOptionsPanel = m_pCameraOptionsPanels[ i ]; + if ( !pCurOptionsPanel ) + continue; + + bool bMouseOverButton = m_pCameraButtons[ i ]->IsWithin( nMouseX, nMouseY ); + bool bMouseOverOptionsPanel = pCurOptionsPanel->IsWithin( nMouseX, nMouseY ); + bool bInCameraModeThatMouseIsOver = ReplayCamera()->GetMode() == GetCameraModeFromButtonIndex( (CameraMode_t)i ); + bool bDontCareAboutCameraMode = i == COMPONENT_TIMESCALE; + bool bActivate = ( i == m_nMouseClickedOverCameraSettingsPanel ) || + ( ( ( bInCameraModeThatMouseIsOver || bDontCareAboutCameraMode ) && bMouseOverButton ) || ( bMouseOverOptionsPanel && pCurOptionsPanel->IsVisible() ) ); + pCurOptionsPanel->SetVisible( bActivate ); + } + } + + if ( bLayoutPlayerCells ) + { + LayoutPlayerCells(); + } + + // Setup player name label and temporary camera view + if ( m_pPlayerNameLabel && pGamePlayerResource && pMouseOverCell ) + { + m_pPlayerNameLabel->SetText( pGamePlayerResource->GetPlayerName( iMouseOverPlayerIndex ) ); + m_pPlayerNameLabel->SizeToContents(); + + int nCellPos[2]; + pMouseOverCell->GetPos( nCellPos[0], nCellPos[1] ); + + int nLabelX = MAX( + nCellPos[0], + m_nRedBlueLabelRightX + ); + int nLabelY = m_nBottomPanelStartY + ( m_nBottomPanelHeight - m_pPlayerNameLabel->GetTall() ) / 2; + m_pPlayerNameLabel->SetPos( nLabelX, nLabelY ); + + m_pPlayerNameLabel->SetVisible( true ); + + // Setup camera + pCamera->SetPrimaryTarget( iMouseOverPlayerIndex ); + } + else + { + m_pPlayerNameLabel->SetVisible( false ); + + // Set camera to last valid target + Assert( m_iCurPlayerTarget >= 0 ); + pCamera->SetPrimaryTarget( m_iCurPlayerTarget ); + } + + // If user clicked, assume it was the selected cell and set primary target in camera + if ( iMouseOverPlayerIndex >= 0 ) + { + pCamera->SetPrimaryTarget( iMouseOverPlayerIndex ); + } + else + { + pCamera->SetPrimaryTarget( m_iCurPlayerTarget ); + } + + // fixes a case where the replay would be paused and the player would cycle cameras but the + // target's visibility wouldn't be updated until the replay was unpaused (they would be invisible) + if ( m_bCurrentTargetNeedsVisibilityUpdate ) + { + C_BaseEntity *pTarget = ClientEntityList().GetEnt( pCamera->GetPrimaryTargetIndex() ); + if ( pTarget ) + { + pTarget->UpdateVisibility(); + } + + m_bCurrentTargetNeedsVisibilityUpdate = false; + } + + // If in free-cam mode, add set view event if we're not paused + if ( bInAControllableCameraMode && m_bShownAtLeastOnce && bRecording ) + { + AddSetViewEvent(); + AddTimeScaleEvent( m_flTimeScaleProxy ); + } + + // Set paused state in rec light + const bool bPaused = IsPaused(); + m_pRecLightPanel->UpdatePauseState( bPaused ); + + Achievements_Think( flElapsed ); +} + +void CReplayPerformanceEditorPanel::Achievements_OnSpaceBarPressed() +{ + m_flLastTimeSpaceBarPressed = gpGlobals->realtime; +} + +void CReplayPerformanceEditorPanel::Achievements_Think( float flElapsed ) +{ +// engine->Con_NPrintf( 10, "total time: %f", m_flActiveTimeInEditor ); +// engine->Con_NPrintf( 11, "last time space bar pressed: %f", m_flLastTimeSpaceBarPressed ); + + // Already awarded one this editing session? + if ( m_bAchievementAwarded ) + return; + + // Too much idle time since last activity? + if ( gpGlobals->realtime - m_flLastTimeSpaceBarPressed > 60.0f ) + { + m_flActiveTimeInEditor = 0.0f; + return; + } + + // Accumulate active time + m_flActiveTimeInEditor += flElapsed; + + // Award now if three-minutes of non-idle time has passed + const float flMinutes = 60.0f * 3.0f; + if ( m_flActiveTimeInEditor < flMinutes ) + return; + + Achievements_Grant(); +} + +void CReplayPerformanceEditorPanel::Achievements_Grant() +{ +#if defined( TF_CLIENT_DLL ) + g_AchievementMgrTF.AwardAchievement( ACHIEVEMENT_TF_REPLAY_EDIT_TIME ); +#endif + + // Awarded + m_bAchievementAwarded = true; +} + +bool CReplayPerformanceEditorPanel::IsPaused() +{ + return IsVisible(); +} + +CReplayPerformance *CReplayPerformanceEditorPanel::GetPerformance() const +{ + return g_pReplayPerformanceController->GetPerformance(); +} + +CReplayPerformance *CReplayPerformanceEditorPanel::GetSavedPerformance() const +{ + return g_pReplayPerformanceController->GetSavedPerformance(); +} + +int CReplayPerformanceEditorPanel::GetCameraModeFromButtonIndex( CameraMode_t iCamera ) +{ + switch ( iCamera ) + { + case CAM_FREE: return OBS_MODE_ROAMING; + case CAM_THIRD: return OBS_MODE_CHASE; + case CAM_FIRST: return OBS_MODE_IN_EYE; + } + return CAM_INVALID; +} + +void CReplayPerformanceEditorPanel::UpdateTimeLabels() +{ + CReplay *pPlayingReplay = g_pReplayManager->GetPlayingReplay(); + + if ( !pPlayingReplay || !m_pCurTimeLabel || !m_pTotalTimeLabel ) + return; + + float flCurTime, flTotalTime; + g_pClientReplayContext->GetPlaybackTimes( flCurTime, flTotalTime, pPlayingReplay, GetPerformance() ); + + int nCurRoundedTime = (int)flCurTime; // Essentially floor'd + if ( nCurRoundedTime == m_nLastRoundedTime ) + return; + + m_nLastRoundedTime = nCurRoundedTime; + + // Set current time text + char szTimeText[64]; + V_snprintf( szTimeText, sizeof( szTimeText ), "%s", CReplayTime::FormatTimeString( nCurRoundedTime ) ); + m_pCurTimeLabel->SetText( szTimeText ); + + // Set total time text + V_snprintf( szTimeText, sizeof( szTimeText ), "%s", CReplayTime::FormatTimeString( (int)flTotalTime ) ); + m_pTotalTimeLabel->SetText( szTimeText ); + + // Center between left-most camera button and play/pause button + m_pCurTimeLabel->SizeToContents(); + m_pTotalTimeLabel->SizeToContents(); +} + +void CReplayPerformanceEditorPanel::UpdateCameraSelectionPosition( CameraMode_t nCameraMode ) +{ + Assert( nCameraMode >= 0 && nCameraMode < NCAMS ); + m_iCameraSelection = nCameraMode; + + UpdateCameraButtonImages(); +} + +void CReplayPerformanceEditorPanel::UpdateFreeCamSettings( const SetViewParams_t ¶ms ) +{ + CCameraOptionsPanel_Free *pSettingsPanel = dynamic_cast< CCameraOptionsPanel_Free * >( m_pCameraOptionsPanels[ CAM_FREE ] ); + if ( !pSettingsPanel ) + return; + + pSettingsPanel->SetValue( CCameraOptionsPanel_Free::SLIDER_ACCEL, params.m_flAccel ); + pSettingsPanel->SetValue( CCameraOptionsPanel_Free::SLIDER_SPEED, params.m_flSpeed ); + pSettingsPanel->SetValue( CCameraOptionsPanel_Free::SLIDER_FOV, params.m_flFov ); + pSettingsPanel->SetValue( CCameraOptionsPanel_Free::SLIDER_ROTFILTER, params.m_flRotationFilter ); +} + +void CReplayPerformanceEditorPanel::UpdateTimeScale( float flScale ) +{ + CTimeScaleOptionsPanel *pSettingsPanel = dynamic_cast< CTimeScaleOptionsPanel * >( m_pCameraOptionsPanels[ COMPONENT_TIMESCALE ] ); + if ( !pSettingsPanel ) + return; + + pSettingsPanel->SetValue( CTimeScaleOptionsPanel::SLIDER_TIMESCALE, flScale ); +} + +void CReplayPerformanceEditorPanel::LayoutPlayerCells() +{ + int nPanelHeight = m_pPlayerCellsPanel->GetTall(); + int nCellBuffer = XRES(1); + for ( int i = 0; i < 2; ++i ) + { + int nCurX = m_nRedBlueLabelRightX; + + for ( int j = 0; j <= MAX_PLAYERS; ++j ) + { + CPlayerCell *pCurCell = m_pPlayerCells[i][j]; + if ( !pCurCell->IsVisible() ) + continue; + + // Apply cached settings from .res file + if ( m_pPlayerCellData ) + { + pCurCell->ApplySettings( m_pPlayerCellData ); + } + + const int nY = nPanelHeight/2 + m_nRedBlueSigns[i] * nPanelHeight/4 - pCurCell->GetTall()/2; + pCurCell->SetPos( + nCurX, + nY + ); + + nCurX += pCurCell->GetWide() + nCellBuffer; + } + } +} + +void CReplayPerformanceEditorPanel::PerformLayout() +{ + int w = ScreenWidth(), h = ScreenHeight(); + SetBounds(0,0,w,h); + + // Layout camera options panels + for ( int i = 0; i < NCAMS; ++i ) + { + CCameraOptionsPanel *pCurOptionsPanel = m_pCameraOptionsPanels[ i ]; + if ( !pCurOptionsPanel ) + continue; + + CExImageButton *pCurCameraButton = m_pCameraButtons[ i ]; + if ( !pCurCameraButton ) + continue; + + // Get camera button position + int aCameraButtonPos[2]; + int aBottomPos[2]; + pCurCameraButton->GetPos( aCameraButtonPos[ 0 ], aCameraButtonPos[ 1 ] ); + m_pBottom->GetPos( aBottomPos[ 0 ], aBottomPos[ 1 ] ); + + // Layout the panel now - it should set its own size, which we need to know to position it properly + pCurOptionsPanel->InvalidateLayout( true, true ); + + // Position it + pCurOptionsPanel->SetPos( + aBottomPos[ 0 ] + aCameraButtonPos[ 0 ] + pCurCameraButton->GetWide() - pCurOptionsPanel->GetWide() - XRES( 3 ), + aBottomPos[ 1 ] + aCameraButtonPos[ 1 ] - pCurOptionsPanel->GetTall() + ); + } + + // Setup menu position relative to menu button + int aMenuButtonPos[2]; + m_pMenuButton->GetPos( aMenuButtonPos[0], aMenuButtonPos[1] ); + m_pMenu->SetPos( aMenuButtonPos[0], aMenuButtonPos[1] + m_pMenuButton->GetTall() ); + + // Set player cell panel to be the size of half the bottom panel + int aBottomSize[2]; + m_pBottom->GetSize( aBottomSize[0], aBottomSize[1] ); + m_pPlayerCellsPanel->SetBounds( 0, 0, aBottomSize[0] / 2, m_pPlayerCellsPanel->GetTall() ); + + CExLabel *pRedBlueLabels[2] = { + dynamic_cast< CExLabel * >( m_pPlayerCellsPanel->FindChildByName( "RedLabel" ) ), + dynamic_cast< CExLabel * >( m_pPlayerCellsPanel->FindChildByName( "BlueLabel" ) ) + }; + int nMargins[2] = { (int)XRES( 5 ), (int)YRES( 2 ) }; + for ( int i = 0; i < 2; ++i ) + { + pRedBlueLabels[i]->SizeToContents(); + + const int nY = m_pPlayerCellsPanel->GetTall()/2 + m_nRedBlueSigns[i] * m_pPlayerCellsPanel->GetTall()/4 - pRedBlueLabels[i]->GetTall()/2; + pRedBlueLabels[i]->SetPos( nMargins[0], nY ); + + m_nRedBlueLabelRightX = MAX( m_nRedBlueLabelRightX, nMargins[0] + pRedBlueLabels[i]->GetWide() + nMargins[0] ); + } + + // Position player cells + LayoutPlayerCells(); + + BaseClass::PerformLayout(); +} + +bool CReplayPerformanceEditorPanel::OnStateChangeRequested( const char *pEventStr ) +{ + // If we're already recording, allow the change. + if ( g_pReplayPerformanceController->IsRecording() ) + return true; + + // If we aren't recording and there is no forthcoming data in the playback stream, allow the change. + if ( !g_pReplayPerformanceController->IsPlaybackDataLeft() ) + return true; + + // Otherwise, record the event string and show a dialog asking the user if they're sure they want to nuke. + V_strncpy( m_szSuspendedEvent, pEventStr, sizeof( m_szSuspendedEvent ) ); + ShowConfirmDialog( "#Replay_Warning", "#Replay_NukePerformanceChanges", "#GameUI_Confirm", "#GameUI_CancelBold", OnConfirmDestroyChanges, this, this, REPLAY_SOUND_DIALOG_POPUP ); + + return false; +} + +void CReplayPerformanceEditorPanel::SetButtonTip( wchar_t *pTipText, Panel *pContextPanel ) +{ + // Set the text + m_pButtonTip->SetText( pTipText ); + m_pButtonTip->InvalidateLayout( true, true ); + + // Center relative to context panel + int aPos[2]; + ipanel()->GetAbsPos( pContextPanel->GetVPanel(), aPos[0], aPos[1] ); + const int nX = clamp( + aPos[0] - m_pButtonTip->GetWide() / 2, + 0, + ScreenWidth() - m_pButtonTip->GetWide() - (int) XRES( 40 ) + ); + const int nY = m_nBottomPanelStartY - m_pButtonTip->GetTall() - (int) YRES( 2 ); + m_pButtonTip->SetPos( nX, nY ); +} + +void CReplayPerformanceEditorPanel::ShowButtonTip( bool bShow ) +{ + m_pButtonTip->SetVisible( bShow ); +} + +void CReplayPerformanceEditorPanel::ShowSavingDialog() +{ + Assert( !m_pSavingDlg ); + m_pSavingDlg = new CSavingDialog( ReplayUI_GetPerformanceEditor() ); + ShowWaitingDialog( m_pSavingDlg, "#Replay_Saving", true, false, -1 ); +} + +void CReplayPerformanceEditorPanel::ShowPanel( bool bShow ) +{ + if ( bShow == IsVisible() ) + return; + + if ( bShow ) + { + // We are now performing. + m_pRecLightPanel->SetPerforming( true ); + + // Disable keyboard input on all panels added to the list + FOR_EACH_LL( m_lstDisableKeyboardInputPanels, it ) + { + m_lstDisableKeyboardInputPanels[ it ]->SetKeyBoardInputEnabled( false ); + } + + DisplayPerformanceTip( "#Replay_PerfTip_ExitPerfMode", &replay_perftip_count_exit, MAX_TIP_DISPLAYS ); + + // Fire a message the game DLL can intercept (for achievements, etc). + IGameEvent *event = gameeventmanager->CreateEvent( "entered_performance_mode" ); + if ( event ) + { + gameeventmanager->FireEventClientSide( event ); + } + + // Play a sound + surface()->PlaySound( "replay\\enterperformancemode.wav" ); + } + else + { + // Display a tip + DisplayPerformanceTip( "#Replay_PerfTip_EnterPerfMode", &replay_perftip_count_enter, MAX_TIP_DISPLAYS ); + + // Play a sound + surface()->PlaySound( "replay\\exitperformancemode.wav" ); + } + + // Show mouse cursor + SetMouseInputEnabled( bShow ); + SetVisible( bShow ); + MakePopup( bShow ); + + // Avoid waiting for next OnThink() to hide background images + m_pRecLightPanel->UpdatePauseState( bShow ); + m_pRecLightPanel->UpdateBackgroundVisibility(); + + // Play or pause + if ( bShow ) + { + PauseDemo(); + } + else + { + PlayDemo(); + } + + // Keep controller informed about pause state so that it can throw away unimportant events during pause if it's recording. + g_pReplayPerformanceController->NotifyPauseState( bShow ); +} + +bool CReplayPerformanceEditorPanel::OnEndOfReplayReached() +{ + if ( m_bShownAtLeastOnce ) + { + ShowPanel( true ); + DisplayPerformanceTip( "#Replay_PerfTip_EndOfReplayReached" ); + + // Don't end demo playback yet. + return true; + } + + // Let the demo player end demo playback + return false; +} + +void CReplayPerformanceEditorPanel::AddSetViewEvent() +{ + if ( !g_pReplayManager->GetPlayingReplay() ) + return; + + if ( !g_pReplayPerformanceController ) + return; + + Vector pos; + QAngle angles; + float fov; + ReplayCamera()->GetCachedView( pos, angles, fov ); + + SetViewParams_t params; + params.m_flTime = GetPlaybackTime(); + params.m_flFov = fov; + params.m_pOrigin = &pos; + params.m_pAngles = &angles; + + params.m_flAccel = ReplayCamera()->m_flRoamingAccel; + params.m_flSpeed = ReplayCamera()->m_flRoamingSpeed; + params.m_flRotationFilter = ReplayCamera()->m_flRoamingRotFilterFactor; + + g_pReplayPerformanceController->AddEvent_Camera_SetView( params ); +} + +// Input should be in [0,1] +void CReplayPerformanceEditorPanel::AddTimeScaleEvent( float flTimeScale ) +{ + if ( !g_pReplayManager->GetPlayingReplay() ) + return; + + if ( !g_pReplayPerformanceController ) + return; + + g_pReplayPerformanceController->AddEvent_TimeScale( GetPlaybackTime(), flTimeScale ); +} + +void CReplayPerformanceEditorPanel::UpdateCameraButtonImages( bool bForceUnselected/*=false*/ ) +{ + CReplayPerformance *pPerformance = GetPerformance(); + for ( int i = 0; i < NCAMS; ++i ) + { + CFmtStr fmtFile( + gs_pBaseComponentNames[i], + gs_pCamNames[i], + ( !bForceUnselected && ( !pPerformance || g_pReplayPerformanceController->IsRecording() ) && i == m_iCameraSelection ) ? "_selected" : "" + ); + + if ( m_pCameraButtons[ i ] ) + { + m_pCameraButtons[ i ]->SetSubImage( fmtFile.Access() ); + } + } +} + +void CReplayPerformanceEditorPanel::EnsureRecording( bool bShouldSnip ) +{ + // Not recording? + if ( !g_pReplayPerformanceController->IsRecording() ) + { + // Start recording - snip if needed. + g_pReplayPerformanceController->StartRecording( GetReplay(), bShouldSnip ); + } +} + +void CReplayPerformanceEditorPanel::ToggleMenu() +{ + if ( !m_pMenu ) + return; + + // Show/hide + const bool bShow = !m_pMenu->IsVisible(); + m_pMenu->SetVisible( bShow ); +} + +void CReplayPerformanceEditorPanel::SaveAs( const wchar_t *pTitle ) +{ + if ( !g_pReplayPerformanceController->SaveAsAsync( pTitle ) ) + { + DisplaySavedTip( false ); + } + + ShowSavingDialog(); +} + +/*static*/ void CReplayPerformanceEditorPanel::OnConfirmSaveAs( bool bShouldSave, wchar_t *pTitle, void *pContext ) +{ + // NOTE: Assumes that overwriting has already been confirmed by the user. + + if ( !bShouldSave ) + return; + + CReplayPerformanceEditorPanel *pThis = (CReplayPerformanceEditorPanel *)pContext; + pThis->SaveAs( pTitle ); + + surface()->PlaySound( "replay\\saved_take.wav" ); +} + +void CReplayPerformanceEditorPanel::ShowRewindConfirmMessage() +{ + ShowMessageBox( "#Replay_RewindWarningTitle", "#Replay_RewindWarningMsg", "#GameUI_OK", OnConfirmRewind, NULL, (void *)this ); + surface()->PlaySound( "replay\\replaydialog_warn.wav" ); +} + +/*static*/ void CReplayPerformanceEditorPanel::OnConfirmRewind( bool bConfirmed, void *pContext ) +{ + if ( bConfirmed ) + { + if ( pContext ) + { + CReplayPerformanceEditorPanel *pEditor = (CReplayPerformanceEditorPanel *)pContext; + pEditor->OnCommand( "goto_back" ); + } + } +} + +void CReplayPerformanceEditorPanel::OnMenuCommand_Save( bool bExitEditorWhenDone/*=false*/ ) +{ + // If this is the first time we're saving this performance, do a save-as. + if ( !g_pReplayPerformanceController->HasSavedPerformance() ) + { + OnMenuCommand_SaveAs( bExitEditorWhenDone ); + return; + } + + // Regular save + if ( !g_pReplayPerformanceController->SaveAsync() ) + { + DisplaySavedTip( false ); + } + + // Show saving dialog + ShowSavingDialog(); + + // Exit editor? + if ( bExitEditorWhenDone ) + { + OnMenuCommand_Exit(); + } +} + +void CReplayPerformanceEditorPanel::OnMenuCommand_SaveAs( bool bExitEditorWhenDone/*=false*/ ) +{ + ReplayUI_ShowPerformanceSaveDlg( OnConfirmSaveAs, this, GetReplay(), bExitEditorWhenDone ); +} + +void CReplayPerformanceEditorPanel::DisplaySavedTip( bool bSucceess ) +{ + DisplayPerformanceTip( bSucceess ? "#Replay_PerfTip_Saved" : "#Replay_PerfTip_SaveFailed" ); +} + +void CReplayPerformanceEditorPanel::OnSaveComplete() +{ + DisplaySavedTip( g_pReplayPerformanceController->GetLastSaveStatus() ); + + m_pSavingDlg = NULL; +} + +void CReplayPerformanceEditorPanel::HandleUiToggle() +{ + if ( !TFModalStack()->IsEmpty() ) + return; + + PauseDemo(); + Exit_ShowDialogs(); +} + +void CReplayPerformanceEditorPanel::Exit() +{ + engine->ClientCmd_Unrestricted( "disconnect" ); +} + +void CReplayPerformanceEditorPanel::Exit_ShowDialogs() +{ + if ( g_pReplayPerformanceController->IsDirty() ) + { + ShowConfirmDialog( "#Replay_DiscardTitle", "#Replay_DiscardChanges", "#Replay_Discard", "#Replay_Cancel", OnConfirmDiscard, NULL, this, REPLAY_SOUND_DIALOG_POPUP ); + } + else + { + ShowConfirmDialog( "#Replay_ExitEditorTitle", "#Replay_BackToReplays", "#GameUI_Confirm", "#Replay_Cancel", OnConfirmExit, NULL, this, REPLAY_SOUND_DIALOG_POPUP ); + } +} + +void CReplayPerformanceEditorPanel::OnMenuCommand_Exit() +{ + Exit_ShowDialogs(); +} + +void CReplayPerformanceEditorPanel::OnCommand( const char *command ) +{ + float flCurTime = GetPlaybackTime(); + + g_bIsReplayRewinding = false; + + if ( !V_stricmp( command, "toggle_menu" ) ) + { + ToggleMenu(); + } + else if ( !V_strnicmp( command, "menu_", 5 ) ) + { + const char *pMenuCommand = command + 5; + + if ( !V_stricmp( pMenuCommand, "save" ) ) + { + OnMenuCommand_Save(); + } + else if ( !V_stricmp( pMenuCommand, "saveas" ) ) + { + OnMenuCommand_SaveAs(); + } + else if ( !V_stricmp( pMenuCommand, "exit" ) ) + { + OnMenuCommand_Exit(); + } + } + else if ( !V_stricmp( command, "close" ) ) + { + ShowPanel( false ); + MarkForDeletion(); + return; + } + else if ( !V_stricmp( command, "play" ) ) + { + ShowPanel( false ); + return; + } + else if ( !V_stricmp( command, "pause" ) ) + { + ShowPanel( true ); + return; + } + else if ( !V_strnicmp( command, "timescale_", 10 ) ) + { + const char *pTimeScaleCmd = command + 10; + if ( !V_stricmp( pTimeScaleCmd, "showpanel" ) ) + { + // If we're playing back, pop up a dialog asking if the user is sure they want to nuke the + // rest of whatever is playing back. + if ( !OnStateChangeRequested( command ) ) + return; + + EnsureRecording(); + } + } + else if ( !V_strnicmp( command, "settick_", 8 ) ) + { + const char *pSetType = command + 8; + const int nCurTick = engine->GetDemoPlaybackTick(); + + if ( !V_stricmp( pSetType, "in" ) ) + { + SetOrRemoveInTick( nCurTick, true ); + } + else if ( !V_stricmp( pSetType, "out" ) ) + { + SetOrRemoveOutTick( nCurTick, true ); + } + + // Save the replay + CReplay *pReplay = GetReplay(); + if ( pReplay ) + { + g_pReplayManager->FlagReplayForFlush( pReplay, true ); + } + + return; + } + else if ( !V_strnicmp( command, "goto_", 5 ) ) + { + const char *pGotoType = command + 5; + CReplay *pReplay = GetReplay(); + if ( pReplay ) + { + const CReplayPerformance *pScratchPerformance = g_pReplayPerformanceController->GetPerformance(); + const CReplayPerformance *pSavedPerformance = g_pReplayPerformanceController->GetSavedPerformance(); + const CReplayPerformance *pPerformance = pScratchPerformance ? pScratchPerformance : pSavedPerformance; + + const int nCurTick = engine->GetDemoPlaybackTick(); + + // If in or out ticks are set in the performance, use those for the 'full' rewind/fast-forward + const int nStartTick = MAX( 0, ( pPerformance && pPerformance->HasInTick() ) ? pPerformance->m_nTickIn : pReplay->m_nSpawnTick ); + const int nEndTick = MAX( // The MAX() here will keep us from going back in time if we're already past the "end" tick + nCurTick, + ( ( pPerformance && pPerformance->HasOutTick() ) ? + pPerformance->m_nTickOut : + ( nStartTick + TIME_TO_TICKS( pReplay->m_flLength ) ) ) + - TIME_TO_TICKS( 0.1f ) + ); + + int nGotoTick = 0; + bool bGoingBack = false; + + if ( !V_stricmp( pGotoType, "start" ) ) + { + bGoingBack = true; + nGotoTick = nStartTick; + } + else if ( !V_stricmp( pGotoType, "back" ) ) + { + // If this is the first time rewinding, display a message + if ( !replay_replayeditor_rewindmsgcounter.GetBool() ) + { + replay_replayeditor_rewindmsgcounter.SetValue( 1 ); + ShowRewindConfirmMessage(); + return; + } + + bGoingBack = true; + nGotoTick = nCurTick - TIME_TO_TICKS( 10.0f ); + } + else if ( !V_stricmp( pGotoType, "end" ) ) + { + nGotoTick = nEndTick; // Don't go back in time + } + + // Clamp it + nGotoTick = clamp( nGotoTick, nStartTick, nEndTick ); + + // If going back... + if ( bGoingBack ) + { + // ...and notify the recorder that we're skipping, which we only need to do if we're going backwards + g_pReplayPerformanceController->NotifyRewinding(); + g_bIsReplayRewinding = true; + } + + // Go to the given tick and pause + CFmtStr fmtCmd( "demo_gototick %i\ndemo_pause\n", nGotoTick ); + engine->ClientCmd_Unrestricted( fmtCmd.Access() ); + } + return; + } + else if ( !V_strnicmp( command, "setcamera_", 10 ) ) + { + const char *pCamType = command + 10; + int nEntIndex = ReplayCamera()->GetPrimaryTargetIndex(); + + // If we're playing back, pop up a dialog asking if the user is sure they want to nuke the + // rest of whatever is playing back. + if ( !OnStateChangeRequested( command ) ) + return; + + EnsureRecording(); + + if ( !V_stricmp( pCamType, "first" ) ) + { + ReplayCamera()->SetMode( OBS_MODE_IN_EYE ); + UpdateCameraSelectionPosition( CAM_FIRST ); + m_bCurrentTargetNeedsVisibilityUpdate = true; + g_pReplayPerformanceController->AddEvent_Camera_Change_FirstPerson( flCurTime, nEntIndex ); + } + else if ( !V_stricmp( pCamType, "third" ) ) + { + ReplayCamera()->SetMode( OBS_MODE_CHASE ); + UpdateCameraSelectionPosition( CAM_THIRD ); + m_bCurrentTargetNeedsVisibilityUpdate = true; + g_pReplayPerformanceController->AddEvent_Camera_Change_ThirdPerson( flCurTime, nEntIndex ); + AddSetViewEvent(); + } + else if ( !V_stricmp( pCamType, "free" ) ) + { + ReplayCamera()->SetMode( OBS_MODE_ROAMING ); + UpdateCameraSelectionPosition( CAM_FREE ); + m_bCurrentTargetNeedsVisibilityUpdate = true; + g_pReplayPerformanceController->AddEvent_Camera_Change_Free( flCurTime ); + AddSetViewEvent(); + DisplayPerformanceTip( "#Replay_PerfTip_EnterFreeCam", &replay_perftip_count_freecam_enter, MAX_TIP_DISPLAYS ); + } + + return; + } + else + { + engine->ClientCmd( const_cast<char *>( command ) ); + return; + } + + BaseClass::OnCommand( command ); +} + +void CReplayPerformanceEditorPanel::OnConfirmDestroyChanges( bool bConfirmed, void *pContext ) +{ + AssertMsg( pContext, "Should have a context! Fix me!" ); + if ( pContext && bConfirmed ) + { + CReplayPerformanceEditorPanel *pEditorPanel = (CReplayPerformanceEditorPanel *)pContext; + if ( bConfirmed ) + { + CReplay *pReplay = pEditorPanel->GetReplay(); + g_pReplayPerformanceController->StartRecording( pReplay, true ); + + // Reissue the command. + pEditorPanel->OnCommand( pEditorPanel->m_szSuspendedEvent ); + + // Play a sound + surface()->PlaySound( "replay\\snip.wav" ); + } + + // Clear suspended event + pEditorPanel->m_szSuspendedEvent[ 0 ] = '\0'; + + // Make sure mouse is free + pEditorPanel->SetMouseInputEnabled( true ); + + DisplayPerformanceTip( "#Replay_PerfTip_Snip" ); + } +} + +/*static*/ void CReplayPerformanceEditorPanel::OnConfirmDiscard( bool bConfirmed, void *pContext ) +{ + CReplayPerformanceEditorPanel *pEditor = (CReplayPerformanceEditorPanel *)pContext; + if ( bConfirmed ) + { + pEditor->Exit(); + } + else + { + if ( !pEditor->IsVisible() ) + { + PlayDemo(); + } + } +} + +/*static*/ void CReplayPerformanceEditorPanel::OnConfirmExit( bool bConfirmed, void *pContext ) +{ + CReplayPerformanceEditorPanel *pEditor = (CReplayPerformanceEditorPanel *)pContext; + if ( bConfirmed ) + { + pEditor->Exit(); + } + else + { + if ( !pEditor->IsVisible() ) + { + PlayDemo(); + } + } +} + +void CReplayPerformanceEditorPanel::SetOrRemoveInTick( int nTick, bool bRemoveIfSet ) +{ + SetOrRemoveTick( nTick, true, bRemoveIfSet ); +} + +void CReplayPerformanceEditorPanel::SetOrRemoveOutTick( int nTick, bool bRemoveIfSet ) +{ + SetOrRemoveTick( nTick, false, bRemoveIfSet ); +} + +void CReplayPerformanceEditorPanel::SetOrRemoveTick( int nTick, bool bUseInTick, bool bRemoveIfSet ) +{ + CReplayPerformance *pPerformance = GetPerformance(); + AssertMsg( pPerformance, "Performance should always be valid by this point." ); + + ControlButtons_t iButton; + int *pResultTick; + const char *pSetTickKey; + const char *pUnsetTickKey; + if ( bUseInTick ) + { + pResultTick = &pPerformance->m_nTickIn; + iButton = CTRLBUTTON_IN; + pSetTickKey = "#Replay_PerfTip_InPointSet"; + pUnsetTickKey = "#Replay_PerfTip_InPointRemoved"; + } + else + { + pResultTick = &pPerformance->m_nTickOut; + iButton = CTRLBUTTON_OUT; + pSetTickKey = "#Replay_PerfTip_OutPointSet"; + pUnsetTickKey = "#Replay_PerfTip_OutPointRemoved"; + } + + // Tick explicitly being removed? Caller passing in -1? + const bool bRemoving = nTick < 0; + + // If tick already exists and we want to remove, remove it + bool bSetting; + if ( ( *pResultTick >= 0 && bRemoveIfSet ) || bRemoving ) + { + *pResultTick = -1; + bSetting = false; + } + else + { + *pResultTick = nTick; + bSetting = true; + } + + // Display the appropriate tip + DisplayPerformanceTip( bSetting ? pSetTickKey : pUnsetTickKey ); + + // Select/unselect button + CExImageButton *pButton = m_pCtrlButtons[ iButton ]; + pButton->SetSelected( bSetting ); + pButton->InvalidateLayout( true, true ); // Without this, buttons don't update immediately + + // Mark the performance as dirty + g_pReplayPerformanceController->NotifyDirty(); +} + +CReplay *CReplayPerformanceEditorPanel::GetReplay() +{ + return g_pReplayManager->GetReplay( m_hReplay ); +} + +void CReplayPerformanceEditorPanel::OnRewindComplete() +{ + // Get rid of any "selected" icon - this will happen as soon as we actually start playing back + // events, but if we aren't playing back events yet we need to explicitly tell the icons not + // to display their "selected" versions. + UpdateCameraButtonImages( true ); +} + +//----------------------------------------------------------------------------- + +static DHANDLE<CReplayPerformanceEditorPanel> g_ReplayPerformanceEditorPanel; + +//----------------------------------------------------------------------------- + +CReplayPerformanceEditorPanel *ReplayUI_InitPerformanceEditor( ReplayHandle_t hReplay ) +{ + if ( !g_ReplayPerformanceEditorPanel.Get() ) + { + g_ReplayPerformanceEditorPanel = SETUP_PANEL( new CReplayPerformanceEditorPanel( NULL, hReplay ) ); + g_ReplayPerformanceEditorPanel->InvalidateLayout( false, true ); + } + + // Notify recorder of editor + g_pReplayPerformanceController->SetEditor( g_ReplayPerformanceEditorPanel.Get() ); + + return g_ReplayPerformanceEditorPanel; +} + +void ReplayUI_ClosePerformanceEditor() +{ + if ( g_ReplayPerformanceEditorPanel ) + { + g_ReplayPerformanceEditorPanel->MarkForDeletion(); + g_ReplayPerformanceEditorPanel = NULL; + } +} + +CReplayPerformanceEditorPanel *ReplayUI_GetPerformanceEditor() +{ + return g_ReplayPerformanceEditorPanel; +} + +#if _DEBUG +CON_COMMAND_F( replay_showperfeditor, "Show performance editor", FCVAR_CLIENTDLL ) +{ + ReplayUI_ClosePerformanceEditor(); + ReplayUI_InitPerformanceEditor( REPLAY_HANDLE_INVALID ); +} + +CON_COMMAND_F( replay_tiptest, "", FCVAR_CLIENTDLL ) +{ + DisplayPerformanceTip( "#Replay_PerfTip_EnterFreeCam" ); +} +#endif + +#endif |