512 lines
14 KiB
C++
512 lines
14 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
//=======================================================================================//
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
|
|
#include "replaydemoplayer.h"
|
|
#include "replay/ireplaymoviemanager.h"
|
|
#include "replay/ireplayperformancemanager.h"
|
|
#include "replay/ireplaymovierenderer.h"
|
|
#include "replay/ireplayperformancecontroller.h"
|
|
#include "replay/ireplaymanager.h"
|
|
#include "replay/replay.h"
|
|
#include "replay/replayutils.h"
|
|
#include "replay/shared_defs.h"
|
|
#include "replay/iclientreplay.h"
|
|
#include "replay/performance.h"
|
|
#include "replay_internal.h"
|
|
#include "cmd.h"
|
|
#include "KeyValues.h"
|
|
#include "cdll_engine_int.h"
|
|
#include "host.h"
|
|
#include "fmtstr.h"
|
|
#include "vgui_baseui_interface.h"
|
|
|
|
#ifndef DEDICATED
|
|
#include "screen.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
CReplayDemoPlayer s_ReplayDemoPlayer;
|
|
IDemoPlayer *g_pReplayDemoPlayer = &s_ReplayDemoPlayer;
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
ConVar replay_ignorereplayticks( "replay_ignorereplayticks", "0" );
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CReplayDemoPlayer, IReplayDemoPlayer, INTERFACEVERSION_REPLAYDEMOPLAYER, s_ReplayDemoPlayer );
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
CReplayDemoPlayer::CReplayDemoPlayer()
|
|
: m_pMovie( NULL ),
|
|
m_nCurReplayIndex( 0 ),
|
|
m_flStartRenderTime( 0.0f ),
|
|
m_bInStartPlayback( false ),
|
|
m_bStopCommandEncountered( false ),
|
|
m_bFullSignonStateReached( false )
|
|
{
|
|
}
|
|
|
|
void CReplayDemoPlayer::ClearReplayList()
|
|
{
|
|
m_vecReplaysToPlay.PurgeAndDeleteElements();
|
|
}
|
|
|
|
void CReplayDemoPlayer::AddReplayToList( ReplayHandle_t hReplay, int iPerformance )
|
|
{
|
|
// Make sure the replay handle's OK
|
|
CReplay *pReplay = g_pReplayManager->GetReplay( hReplay );
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
// Create new info
|
|
PlaybackInfo_t *pNewPlaybackInfo = new PlaybackInfo_t();
|
|
|
|
// Cache handle & performance
|
|
pNewPlaybackInfo->m_hReplay = hReplay;
|
|
pNewPlaybackInfo->m_iPerformance = iPerformance;
|
|
|
|
// Figure out replay spawn/spawn+length ticks
|
|
pNewPlaybackInfo->m_nStartTick = pReplay->m_nSpawnTick;
|
|
pNewPlaybackInfo->m_nEndTick = -1;
|
|
|
|
const int nLengthInTicks = TIME_TO_TICKS( pReplay->m_flLength );
|
|
if ( nLengthInTicks > 0 )
|
|
{
|
|
pNewPlaybackInfo->m_nEndTick = pReplay->m_nSpawnTick + nLengthInTicks;
|
|
}
|
|
|
|
// If a performance was specified, override ticks as appropriate
|
|
if ( iPerformance >= 0 )
|
|
{
|
|
// Get the performance from the replay
|
|
const CReplayPerformance *pPerformance = pReplay->GetPerformance( iPerformance );
|
|
if ( pPerformance->m_nTickIn >= 0 )
|
|
{
|
|
pNewPlaybackInfo->m_nStartTick = pPerformance->m_nTickIn;
|
|
}
|
|
if ( pPerformance->m_nTickOut >= 0 )
|
|
{
|
|
pNewPlaybackInfo->m_nEndTick = pPerformance->m_nTickOut;
|
|
}
|
|
}
|
|
|
|
// Cache
|
|
m_vecReplaysToPlay.AddToTail( pNewPlaybackInfo );
|
|
}
|
|
|
|
CReplay *CReplayDemoPlayer::GetCurrentReplay()
|
|
{
|
|
PlaybackInfo_t *pCurrentPlaybackInfo = GetCurrentPlaybackInfo();
|
|
if ( !pCurrentPlaybackInfo )
|
|
return NULL;
|
|
|
|
return g_pReplayManager->GetReplay( pCurrentPlaybackInfo->m_hReplay );
|
|
}
|
|
|
|
const CReplay *CReplayDemoPlayer::GetCurrentReplay() const
|
|
{
|
|
return const_cast< CReplayDemoPlayer * >( this )->GetCurrentReplay();
|
|
}
|
|
|
|
CReplayPerformance *CReplayDemoPlayer::GetCurrentPerformance()
|
|
{
|
|
const PlaybackInfo_t *pCurrentPlaybackInfo = GetCurrentPlaybackInfo();
|
|
if ( !pCurrentPlaybackInfo )
|
|
return NULL;
|
|
|
|
CReplay *pReplay = GetCurrentReplay();
|
|
if ( !pReplay )
|
|
return NULL;
|
|
|
|
if ( pCurrentPlaybackInfo->m_iPerformance < 0 )
|
|
return NULL;
|
|
|
|
return pReplay->GetPerformance( pCurrentPlaybackInfo->m_iPerformance );
|
|
}
|
|
|
|
CReplayDemoPlayer::PlaybackInfo_t *CReplayDemoPlayer::GetCurrentPlaybackInfo()
|
|
{
|
|
if ( m_vecReplaysToPlay.Count() == 0 )
|
|
return NULL;
|
|
|
|
return m_vecReplaysToPlay[ m_nCurReplayIndex ];
|
|
}
|
|
|
|
const CReplayDemoPlayer::PlaybackInfo_t *CReplayDemoPlayer::GetCurrentPlaybackInfo() const
|
|
{
|
|
return const_cast< CReplayDemoPlayer * >( this )->GetCurrentPlaybackInfo();
|
|
}
|
|
|
|
void CReplayDemoPlayer::PauseReplay()
|
|
{
|
|
PausePlayback( -1.0f );
|
|
}
|
|
|
|
bool CReplayDemoPlayer::IsReplayPaused()
|
|
{
|
|
return IsPlaybackPaused();
|
|
}
|
|
|
|
void CReplayDemoPlayer::ResumeReplay()
|
|
{
|
|
ResumePlayback();
|
|
}
|
|
|
|
void CReplayDemoPlayer::OnSignonStateFull()
|
|
{
|
|
m_bFullSignonStateReached = true;
|
|
}
|
|
|
|
netpacket_t *CReplayDemoPlayer::ReadPacket( void )
|
|
{
|
|
if ( !m_bStopCommandEncountered )
|
|
{
|
|
return BaseClass::ReadPacket();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
float CReplayDemoPlayer::GetPlaybackTimeScale()
|
|
{
|
|
if ( g_pReplayPerformanceController )
|
|
{
|
|
return g_pReplayPerformanceController->GetPlaybackTimeScale();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
void CReplayDemoPlayer::OnStopCommand()
|
|
{
|
|
if ( m_bStopCommandEncountered )
|
|
return;
|
|
|
|
m_bStopCommandEncountered = true;
|
|
|
|
if ( !g_pClientReplay->OnEndOfReplayReached() )
|
|
{
|
|
BaseClass::OnStopCommand();
|
|
}
|
|
}
|
|
|
|
bool CReplayDemoPlayer::StartPlayback( const char *pFilename, bool bAsTimeDemo )
|
|
{
|
|
if ( !Replay_IsSupportedModAndPlatform() )
|
|
return false;
|
|
|
|
CInStartPlaybackGuard InStartPlaybackGuard( m_bInStartPlayback );
|
|
|
|
const PlaybackInfo_t *pPlaybackInfo = GetCurrentPlaybackInfo();
|
|
if ( !pPlaybackInfo )
|
|
return false;
|
|
|
|
// always display progress bar to ensure load screen background is redraw
|
|
EngineVGui()->EnabledProgressBarForNextLoad();
|
|
|
|
if ( !BaseClass::StartPlayback( pFilename, bAsTimeDemo ) )
|
|
{
|
|
DisplayFailedToPlayMsg( pPlaybackInfo->m_iPerformance );
|
|
return false;
|
|
}
|
|
|
|
CReplay *pReplay = GetCurrentReplay();
|
|
if ( !pReplay )
|
|
return false;
|
|
|
|
// Set this flag so we can detect whether the replay made it all the way to full signon state,
|
|
// otherwise we'll display a message StopPlayback() is called.
|
|
m_bFullSignonStateReached = false;
|
|
|
|
// Reset so when we see a dem_stop we will handle it
|
|
m_bStopCommandEncountered = false;
|
|
|
|
// Reset skip to tick now
|
|
m_nSkipToTick = -1;
|
|
|
|
// Reset the rendering cancelled flag now
|
|
g_pReplayMovieManager->ClearRenderCancelledFlag();
|
|
|
|
// Setup playback timeframe
|
|
if ( pPlaybackInfo->m_nStartTick >= 0 && !replay_ignorereplayticks.GetBool() )
|
|
{
|
|
SkipToTick( pPlaybackInfo->m_nStartTick, false, false );
|
|
}
|
|
if ( pPlaybackInfo->m_nEndTick >= 0 && !replay_ignorereplayticks.GetBool() )
|
|
{
|
|
SetEndTick( pPlaybackInfo->m_nEndTick );
|
|
}
|
|
|
|
if ( g_pReplayMovieManager->IsRendering() )
|
|
{
|
|
#ifdef USE_WEBM_FOR_REPLAY
|
|
const char *pExtension = ".webm";
|
|
#else
|
|
const char *pExtension = ".mov";
|
|
#endif
|
|
|
|
// Start recording the movie
|
|
char szIdealFilename[ MAX_OSPATH ];
|
|
V_FileBase( pFilename, szIdealFilename, sizeof( szIdealFilename ) );
|
|
V_strcat( szIdealFilename, va( "_%i", pReplay->m_nSpawnTick ), sizeof( szIdealFilename ) );
|
|
V_SetExtension( szIdealFilename, pExtension, sizeof( szIdealFilename ) );
|
|
|
|
char szRenderPath[ MAX_OSPATH ];
|
|
V_snprintf( szRenderPath, sizeof( szRenderPath ), "%s%c%s%c%s%c%s",
|
|
com_gamedir, CORRECT_PATH_SEPARATOR, SUBDIR_REPLAY, CORRECT_PATH_SEPARATOR,
|
|
SUBDIR_CLIENT, CORRECT_PATH_SEPARATOR, SUBDIR_RENDERED
|
|
);
|
|
|
|
char szActualFilename[ MAX_OSPATH ];
|
|
Replay_GetFirstAvailableFilename( szActualFilename, sizeof( szActualFilename ), szIdealFilename,
|
|
pExtension, szRenderPath, 0 );
|
|
|
|
// Create an entry in the movie manager & save to disk
|
|
m_pMovie = g_pReplayMovieManager->CreateAndAddMovie( pReplay->GetHandle() );
|
|
m_pMovie->SetMovieFilename( szActualFilename );
|
|
wchar_t wszMovieTitle[MAX_REPLAY_TITLE_LENGTH] = L"";
|
|
if ( pPlaybackInfo->m_iPerformance < 0 )
|
|
{
|
|
g_pReplayMovieManager->GetCachedMovieTitleAndClear( wszMovieTitle, MAX_REPLAY_TITLE_LENGTH );
|
|
}
|
|
else
|
|
{
|
|
const CReplayPerformance *pPerformance = pReplay->GetPerformance( pPlaybackInfo->m_iPerformance ); AssertMsg( pPerformance, "Performance should always be valid!" );
|
|
if ( pPerformance )
|
|
{
|
|
V_wcsncpy( wszMovieTitle, pPerformance->m_wszTitle, sizeof( wszMovieTitle ) );
|
|
}
|
|
}
|
|
m_pMovie->SetMovieTitle( wszMovieTitle );
|
|
g_pReplayMovieManager->SetPendingMovie( m_pMovie );
|
|
g_pReplayMovieManager->FlagMovieForFlush( m_pMovie, true );
|
|
|
|
// Setup the start render time
|
|
m_flStartRenderTime = realtime;
|
|
}
|
|
else
|
|
{
|
|
m_pMovie = NULL;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CReplayDemoPlayer::PlayNextReplay()
|
|
{
|
|
const PlaybackInfo_t *pPlaybackInfo = GetCurrentPlaybackInfo();
|
|
if ( !pPlaybackInfo )
|
|
return;
|
|
|
|
CReplay *pReplay = g_pReplayManager->GetReplay( pPlaybackInfo->m_hReplay );
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
Assert ( pReplay->m_nStatus != CReplay::REPLAYSTATUS_DOWNLOADPHASE );
|
|
|
|
// Reconstruct now if necessary
|
|
g_pClientReplayContext->ReconstructReplayIfNecessary( pReplay );
|
|
|
|
// Open the demo file so we can read the start tick
|
|
const char *pFilename = pReplay->m_strReconstructedFilename.Get();
|
|
if ( !g_pFullFileSystem->FileExists( pFilename ) )
|
|
{
|
|
Warning( "\n** File %s does not exist!\n\n", pFilename );
|
|
DisplayFailedToPlayMsg( pPlaybackInfo->m_iPerformance );
|
|
return;
|
|
}
|
|
|
|
// Construct a con-command to play the demo, starting at the spawn tick.
|
|
// Play the replay using the 'playreplay' command - pass in the performance as well, -1
|
|
// meaning play without a performance.
|
|
const char *pCmd = "replay_hidebrowser\ngameui_hide\nprogress_enable\n";
|
|
|
|
// Execute the command
|
|
Cbuf_AddText( pCmd );
|
|
Cbuf_Execute();
|
|
|
|
// Use the replay demo player
|
|
extern IDemoPlayer *g_pReplayDemoPlayer;
|
|
demoplayer = g_pReplayDemoPlayer;
|
|
|
|
// Open the demo file
|
|
if ( demoplayer->StartPlayback( pFilename, false ) )
|
|
{
|
|
// Remove extension
|
|
char szBasename[ MAX_OSPATH ];
|
|
V_StripExtension( pFilename, szBasename, sizeof( szBasename ) );
|
|
extern IBaseClientDLL *g_ClientDLL;
|
|
g_ClientDLL->OnDemoPlaybackStart( szBasename );
|
|
}
|
|
else
|
|
{
|
|
SCR_EndLoadingPlaque();
|
|
}
|
|
}
|
|
|
|
void CReplayDemoPlayer::PlayReplay( ReplayHandle_t hReplay, int iPerformance )
|
|
{
|
|
// Cache the replay (this function will only ever cache one)
|
|
s_ReplayDemoPlayer.ClearReplayList();
|
|
s_ReplayDemoPlayer.AddReplayToList( hReplay, iPerformance );
|
|
s_ReplayDemoPlayer.PlayNextReplay();
|
|
}
|
|
|
|
void CReplayDemoPlayer::OnLastDemoInLoopPlayed()
|
|
{
|
|
g_pReplayMovieManager->CompleteRender( true, true );
|
|
}
|
|
|
|
float CReplayDemoPlayer::CalcMovieLength() const
|
|
{
|
|
const PlaybackInfo_t *pPlaybackInfo = GetCurrentPlaybackInfo();
|
|
if ( !pPlaybackInfo )
|
|
return 0.0f;
|
|
|
|
const CReplay *pReplay = GetCurrentReplay();
|
|
if ( !pReplay )
|
|
return 0.0f;
|
|
|
|
const int nStartTick = pPlaybackInfo->m_nStartTick >= 0 ? pPlaybackInfo->m_nStartTick : pReplay->m_nSpawnTick;
|
|
const int nEndTick = pPlaybackInfo->m_nEndTick >= 0 ? pPlaybackInfo->m_nEndTick : ( pReplay->m_nSpawnTick + TIME_TO_TICKS( pReplay->m_flLength ) );
|
|
|
|
const bool bInvalidStartTick = nStartTick < 0;
|
|
const bool bInvalidEndTick = nEndTick < 0;
|
|
|
|
if ( bInvalidEndTick )
|
|
{
|
|
if ( !bInvalidStartTick )
|
|
{
|
|
// Valid start tick, invalid end tick
|
|
return TICKS_TO_TIME( nStartTick ) + pReplay->m_flLength;
|
|
}
|
|
}
|
|
else // Valid end tick.
|
|
{
|
|
if ( !bInvalidStartTick )
|
|
{
|
|
// Valid start tick, valid end tick
|
|
return TICKS_TO_TIME( nEndTick - nStartTick );
|
|
}
|
|
}
|
|
|
|
// Failed to calculate length
|
|
return 0.0f;
|
|
}
|
|
|
|
void CReplayDemoPlayer::StopPlayback()
|
|
{
|
|
if ( !IsPlayingBack() )
|
|
return;
|
|
|
|
BaseClass::StopPlayback();
|
|
|
|
if ( m_bInStartPlayback )
|
|
return;
|
|
|
|
bool bDoneWithBatch = m_nCurReplayIndex >= m_vecReplaysToPlay.Count() - 1;
|
|
bool bRenderCancelled = g_pReplayMovieManager->RenderingCancelled();
|
|
|
|
if ( g_pReplayMovieManager->IsRendering() )
|
|
{
|
|
// Update the replay's state
|
|
CReplay *pReplay = GetCurrentReplay();
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
pReplay->m_bRendered = true; // We have rendered this replay at least once
|
|
|
|
// Save replay
|
|
g_pReplayManager->FlagReplayForFlush( pReplay, false );
|
|
|
|
// Update the movie's state - the render succeeded
|
|
m_pMovie->SetIsRendered( true );
|
|
|
|
// Compute the time it took to render
|
|
m_pMovie->SetRenderTime( MAX( 0, realtime - m_flStartRenderTime ) );
|
|
|
|
// Sets the recorded date & time of the movie
|
|
m_pMovie->CaptureRecordTime();
|
|
|
|
// Get movie length
|
|
m_pMovie->SetLength( CalcMovieLength() );
|
|
|
|
// Save movie
|
|
g_pReplayMovieManager->FlagMovieForFlush( m_pMovie, true );
|
|
|
|
// Kill the renderer, show the browser if we're done rendering all replays
|
|
g_pReplayMovieManager->CompleteRender( true, bDoneWithBatch );
|
|
}
|
|
else if ( !bRenderCancelled ) // Without this check, batch rendering will continue to try and render after cancel
|
|
{
|
|
CReplay *pReplay = GetCurrentReplay();
|
|
if ( !pReplay )
|
|
return;
|
|
|
|
// Get the 'saved' performance from the performance controller, since the performance we initiated playback
|
|
// with may not be the one we want to select in the replay browser. The user may have save as a new performance,
|
|
// in which case we'll want to highlight that one.
|
|
CReplayPerformance *pSavedPerformance = g_pReplayPerformanceController->GetSavedPerformance();
|
|
|
|
// Get the index - FindPerformance() will set the output index to -1 if it can't find the performance
|
|
int iHighlightPerformance;
|
|
pReplay->FindPerformance( pSavedPerformance, iHighlightPerformance );
|
|
|
|
// Notify UI that playback is complete
|
|
g_pClientReplay->OnPlaybackComplete( pReplay->GetHandle(), iHighlightPerformance );
|
|
|
|
// Hide the replay performance editor
|
|
g_pClientReplay->HidePerformanceEditor();
|
|
|
|
// End playback/recording as needed
|
|
g_pReplayPerformanceController->Stop();
|
|
}
|
|
|
|
// Get the playback info before we incremeent the current replay
|
|
const PlaybackInfo_t *pPlaybackInfo = GetCurrentPlaybackInfo();
|
|
|
|
// Play the next replay, if one was queued
|
|
++m_nCurReplayIndex;
|
|
|
|
if ( !bDoneWithBatch && !bRenderCancelled )
|
|
{
|
|
g_pReplayMovieManager->RenderNextMovie();
|
|
}
|
|
else
|
|
{
|
|
m_nCurReplayIndex = 0;
|
|
m_vecReplaysToPlay.PurgeAndDeleteElements();
|
|
|
|
if ( !m_bFullSignonStateReached )
|
|
{
|
|
DisplayFailedToPlayMsg( pPlaybackInfo ? pPlaybackInfo->m_iPerformance : -1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CReplayDemoPlayer::ShouldLoopDemos()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void CReplayDemoPlayer::DisplayFailedToPlayMsg( int iPerformance )
|
|
{
|
|
g_pClientReplay->DisplayReplayMessage(
|
|
iPerformance < 0 ? "#Replay_Err_User_FailedToPlayReplay" : "#Replay_Err_User_FailedToPlayTake",
|
|
false, true, NULL
|
|
);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
#endif // #if defined( REPLAY_ENABLED )
|