//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ //=============================================================================// #include "client_pch.h" #include "enginestats.h" #include "iprediction.h" #include "cl_demo.h" #include "cl_demoactionmanager.h" #include "cl_pred.h" #include "baseautocompletefilelist.h" #include "demofile/demoformat.h" #include "gl_matsysiface.h" #include "materialsystem/imaterialsystemhardwareconfig.h" #include "tier0/etwprof.h" #include "tier0/icommandline.h" #include "vengineserver_impl.h" #include "console.h" #include "dt_common_eng.h" #include "net_chan.h" #include "gl_model_private.h" #include "decal.h" #include "icliententitylist.h" #include "icliententity.h" #include "cl_demouipanel.h" #include "materialsystem/materialsystem_config.h" #include "tier2/tier2.h" #include "vgui_baseui_interface.h" #include "con_nprint.h" #include "networkstringtableclient.h" #ifdef SWDS #include "server.h" #endif // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" static ConVar demo_recordcommands( "demo_recordcommands", "1", FCVAR_CHEAT, "Record commands typed at console into .dem files." ); static ConVar demo_quitafterplayback( "demo_quitafterplayback", "0", 0, "Quits game after demo playback." ); static ConVar demo_debug( "demo_debug", "0", 0, "Demo debug info." ); static ConVar demo_interpolateview( "demo_interpolateview", "1", 0, "Do view interpolation during dem playback." ); static ConVar demo_pauseatservertick( "demo_pauseatservertick", "0", 0, "Pauses demo playback at server tick" ); static ConVar timedemo_runcount( "timedemo_runcount", "0", 0, "Runs time demo X number of times." ); // singeltons: static char g_pStatsFile[MAX_OSPATH] = { 0 }; static bool s_bBenchframe = false; static CDemoRecorder s_ClientDemoRecorder; CDemoRecorder *g_pClientDemoRecorder = &s_ClientDemoRecorder; IDemoRecorder *demorecorder = g_pClientDemoRecorder; static CDemoPlayer s_ClientDemoPlayer; CDemoPlayer *g_pClientDemoPlayer = &s_ClientDemoPlayer; IDemoPlayer *demoplayer = g_pClientDemoPlayer; extern CNetworkStringTableContainer *networkStringTableContainerClient; // This is the number of units under which we are allowed to interpolate, otherwise pop. // This fixes problems with in-level transitions. static ConVar demo_interplimit( "demo_interplimit", "4000", 0, "How much origin velocity before it's considered to have 'teleported' causing interpolation to reset." ); static ConVar demo_avellimit( "demo_avellimit", "2000", 0, "Angular velocity limit before eyes considered snapped for demo playback." ); #define DEMO_HEADER_FILE "demoheader.tmp" // Fast forward convars static ConVar demo_fastforwardstartspeed( "demo_fastforwardstartspeed", "2", 0, "Go this fast when starting to hold FF button." ); static ConVar demo_fastforwardfinalspeed( "demo_fastforwardfinalspeed", "20", 0, "Go this fast when starting to hold FF button." ); static ConVar demo_fastforwardramptime( "demo_fastforwardramptime", "5", 0, "How many seconds it takes to get to full FF speed." ); float scr_demo_override_fov = 0.0f; //----------------------------------------------------------------------------- // Purpose: Implements IDemo and handles demo file i/o // Demos are more or less driven off of network traffic, but there are a few // other kinds of data items that are also included in the demo file: specifically // commands that the client .dll itself issued to the engine are recorded, though they // probably were not the result of network traffic. // At the start of a connection to a map/server, all of the signon, etc. network packets // are buffered. This allows us to actually decide to start recording the demo at a later // time. Once we actually issue the recording command, we don't actually start recording // network traffic, but instead we ask the server for an "uncompressed" packet (otherwise // we wouldn't be able to deal with the incoming packets during playback because we'd be missing the // data to delta from ) and go into a waiting state. Once an uncompressed packet is received, // we unset the waiting state and start recording network packets from that point forward. // Demo's record the elapsed time based on the current client clock minus the time the demo was started // During playback, the elapsed time for playback ( based on the host_time, which is subject to the // host_frametime cvar ) is compared with the elapsed time on the message from the demo file. // If it's not quite time for the message yet, the demo input stream is rewound // The demo system sits at the point where the client is checking to see if any network messages // have arrived from the server. If the message isn't ready for processing, the demo system // just responds that there are no messages waiting and the client continues on // Once a true network message with entity data is read from the demo stream, a couple of other // actions occur. First, the timestamp in the demo file and the view origin/angles corresponding // to the message are cached off. Then, we search ahead (into the future) to find out the next true network message // we are going to read from the demo file. We store of it's elapsed time and view origin/angles // Every frame that the client is rendering, even if there is no data from the demo system, // the engine asks the demo system to compute an interpolated origin and view angles. This // is done by taking the current time on the host and figuring out how far that puts us between // the last read origin from the demo file and the time when we'll actually read out and use the next origin // We use Quaternions to avoid gimbel lock on interpolating the view angles // To make a movie recorded at a fixed frame rate you would simply set the host_framerate to the // desired playback fps ( e.g., 0.02 == 50 fps ), then issue the startmovie command, and then // play the demo. The demo system will think that the engine is running at 50 fps and will pull // messages accordingly, even though movie recording kills the actually framerate. // It will also render frames with render origin/angles interpolated in-between the previous and next origins // even if the recording framerate was not 50 fps or greater. The interpolation provides a smooth visual playback // of the demo information to the client without actually adding latency to the view position (because we are // looking into the future for the position, not buffering the past data ). //----------------------------------------------------------------------------- static bool IsControlCommand( unsigned char cmd ) { return ( (cmd == dem_signon) || (cmd == dem_stop) || (cmd == dem_synctick) || (cmd == dem_datatables ) || (cmd == dem_stringtables) ); } // Puts a flashing overlay on the screen during demo recording/playback static ConVar cl_showdemooverlay( "cl_showdemooverlay", "0", 0, "How often to flash demo recording/playback overlay (0 - disable overlay, -1 - show always)" ); class DemoOverlay { public: DemoOverlay(); ~DemoOverlay(); public: void Tick(); void DrawOverlay( float fSetting ); protected: float m_fLastTickTime; float m_fLastTickOverlay; enum Overlay { OVR_NONE = 0, OVR_REC = 1 << 1, OVR_PLAY = 1 << 2 }; bool m_bTick; int m_maskDrawnOverlay; } g_DemoOverlay; DemoOverlay::DemoOverlay() : m_fLastTickTime( 0.f ), m_fLastTickOverlay( 0.f ), m_bTick( false ), m_maskDrawnOverlay( OVR_NONE ) { } DemoOverlay::~DemoOverlay() { } void DemoOverlay::Tick() { if ( !m_bTick ) { m_bTick = true; float const fRealTime = Sys_FloatTime(); if ( m_fLastTickTime != fRealTime ) { m_fLastTickTime = fRealTime; float const fDelta = m_fLastTickTime - m_fLastTickOverlay; float const fSettingDelta = cl_showdemooverlay.GetFloat(); if ( fSettingDelta <= 0.f || fDelta >= fSettingDelta ) { m_fLastTickOverlay = m_fLastTickTime; DrawOverlay( fSettingDelta ); } } m_bTick = false; } } void DemoOverlay::DrawOverlay( float fSetting ) { int maskDrawnOverlay = OVR_NONE; if ( fSetting < 0.f ) { // Keep drawing maskDrawnOverlay = ( demorecorder->IsRecording() ? OVR_REC : 0 ) | ( demoplayer->IsPlayingBack() ? OVR_PLAY : 0 ); } else if ( fSetting == 0.f ) { // None maskDrawnOverlay = OVR_NONE; } else { // Flash maskDrawnOverlay = ( !m_maskDrawnOverlay ) ? ( ( demorecorder->IsRecording() ? OVR_REC : 0 ) | ( demoplayer->IsPlayingBack() ? OVR_PLAY : 0 ) ) : OVR_NONE; } int const idx = 1; if ( OVR_NONE == maskDrawnOverlay && OVR_NONE != m_maskDrawnOverlay ) { con_nprint_s xprn; memset( &xprn, 0, sizeof( xprn ) ); xprn.index = idx; xprn.time_to_live = -1; Con_NXPrintf( &xprn, "" ); } if ( OVR_PLAY & maskDrawnOverlay ) { con_nprint_s xprn; memset( &xprn, 0, sizeof( xprn ) ); xprn.index = idx; xprn.color[0] = 0.f; xprn.color[1] = 1.f; xprn.color[2] = 0.f; xprn.fixed_width_font = true; xprn.time_to_live = ( fSetting > 0.f ) ? fSetting : 1.f; Con_NXPrintf( &xprn, " PLAY " ); } if ( OVR_REC & maskDrawnOverlay ) { con_nprint_s xprn; memset( &xprn, 0, sizeof( xprn ) ); xprn.index = idx; xprn.color[0] = 1.f; xprn.color[1] = 0.f; xprn.color[2] = 0.f; xprn.fixed_width_font = true; xprn.time_to_live = ( fSetting > 0.f ) ? fSetting : 1.f; Con_NXPrintf( &xprn, " REC " ); } m_maskDrawnOverlay = maskDrawnOverlay; } //----------------------------------------------------------------------------- // Purpose: Mark whether we are waiting for the first uncompressed update packet // Input : waiting - //----------------------------------------------------------------------------- void CDemoRecorder::SetSignonState(int state) { if ( demoplayer->IsPlayingBack() ) return; if ( state == SIGNONSTATE_NEW ) { if ( m_DemoFile.IsOpen() ) { // we are already recording a demo file CloseDemoFile(); // prepare for recording next demo m_nDemoNumber++; } StartupDemoHeader(); } else if ( state == SIGNONSTATE_SPAWN ) { // close demo file header when this packet is finished m_bCloseDemoFile = true; } else if ( state == SIGNONSTATE_FULL ) { if ( m_bRecording ) { StartupDemoFile(); } } } int CDemoRecorder::GetRecordingTick( void ) { if ( cl.m_nMaxClients > 1 ) { return TIME_TO_TICKS( net_time ) - m_nStartTick; } else { return cl.GetClientTickCount() - m_nStartTick; } } void CDemoRecorder::ResyncDemoClock() { if ( cl.m_nMaxClients > 1 ) { m_nStartTick = TIME_TO_TICKS( net_time ); } else { m_nStartTick = cl.GetClientTickCount(); } } //----------------------------------------------------------------------------- // Purpose: // Input : info - //----------------------------------------------------------------------------- void CDemoRecorder::GetClientCmdInfo( democmdinfo_t& info ) { info.flags = FDEMO_NORMAL; if( m_bResetInterpolation ) { info.flags |= FDEMO_NOINTERP; m_bResetInterpolation = false; } g_pClientSidePrediction->GetViewOrigin( info.viewOrigin ); #ifndef SWDS info.viewAngles = cl.viewangles; #endif g_pClientSidePrediction->GetLocalViewAngles( info.localViewAngles ); // Nothing by default info.viewOrigin2.Init(); info.viewAngles2.Init(); info.localViewAngles2.Init(); } void CDemoRecorder::WriteBSPDecals() { decallist_t *decalList = (decallist_t*)malloc( sizeof(decallist_t) * Draw_DecalMax() ); int decalcount = DecalListCreate( decalList ); char data[NET_MAX_PAYLOAD]; bf_write msg; msg.StartWriting( data, NET_MAX_PAYLOAD ); msg.SetDebugName( "DemoFileWriteBSPDecals" ); for ( int i = 0; i < decalcount; i++ ) { decallist_t *entry = &decalList[ i ]; SVC_BSPDecal decal; bool found = false; IClientEntity *clientEntity = entitylist->GetClientEntity( entry->entityIndex ); if ( !clientEntity ) continue; const model_t * pModel = clientEntity->GetModel(); decal.m_Pos = entry->position; decal.m_nEntityIndex = entry->entityIndex; decal.m_nDecalTextureIndex = Draw_DecalIndexFromName( entry->name, &found ); decal.m_nModelIndex = 0; if ( pModel ) { decal.m_nModelIndex = cl.LookupModelIndex( modelloader->GetName( pModel ) ); } decal.WriteToBuffer( msg ); } WriteMessages( msg ); free( decalList ); } void CDemoRecorder::RecordServerClasses( ServerClass *pClasses ) { MEM_ALLOC_CREDIT(); char *pBigBuffer; CUtlBuffer bigBuff; int buffSize = 256*1024; if ( !IsX360() ) { pBigBuffer = (char*)stackalloc( buffSize ); } else { // keep temp large allocations off of stack bigBuff.EnsureCapacity( buffSize ); pBigBuffer = (char*)bigBuff.Base(); } bf_write buf( pBigBuffer, buffSize ); // Send SendTable info. DataTable_WriteSendTablesBuffer( pClasses, &buf ); // Send class descriptions. DataTable_WriteClassInfosBuffer( pClasses, &buf ); // Now write the buffer into the demo file m_DemoFile.WriteNetworkDataTables( &buf, GetRecordingTick() ); } void CDemoRecorder::RecordStringTables() { MEM_ALLOC_CREDIT(); // !KLUDGE! It would be nice if the bit buffer could write into a stream // with the power to grow itself. But it can't. Hence this really bad // kludge void *data = NULL; int dataLen = 512 * 1024; while ( dataLen <= DEMO_FILE_MAX_STRINGTABLE_SIZE ) { data = realloc( data, dataLen ); bf_write buf( data, dataLen ); buf.SetDebugName("CDemoRecorder::RecordStringTables"); buf.SetAssertOnOverflow( false ); // Doesn't turn off all the spew / asserts, but turns off one networkStringTableContainerClient->WriteStringTables( buf ); // Did we fit? if ( !buf.IsOverflowed() ) { // Now write the buffer into the demo file m_DemoFile.WriteStringTables( &buf, GetRecordingTick() ); break; } // Didn't fit. Try doubling the size of the buffer dataLen *= 2; } if ( dataLen > DEMO_FILE_MAX_STRINGTABLE_SIZE ) { Warning( "Failed to RecordStringTables. Trying to record string table that's bigger than max string table size\n" ); } free(data); } void CDemoRecorder::RecordUserInput( int cmdnumber ) { char buffer[256]; bf_write msg( "CDemo::WriteUserCmd", buffer, sizeof(buffer) ); g_ClientDLL->EncodeUserCmdToBuffer( msg, cmdnumber ); m_DemoFile.WriteUserCmd( cmdnumber, buffer, msg.GetNumBytesWritten(), GetRecordingTick() ); } void CDemoRecorder::ResetDemoInterpolation( void ) { m_bResetInterpolation = true; } //----------------------------------------------------------------------------- // Purpose: saves all cvars falgged with FVAR_DEMO to demo file //----------------------------------------------------------------------------- void CDemoRecorder::WriteDemoCvars() { const ConCommandBase *var; for ( var= g_pCVar->GetCommands() ; var ; var=var->GetNext() ) { if ( var->IsCommand() ) continue; const ConVar *pCvar = ( const ConVar * )var; if ( !pCvar->IsFlagSet( FCVAR_DEMO ) ) continue; char cvarcmd[MAX_OSPATH]; Q_snprintf( cvarcmd, sizeof(cvarcmd),"%s \"%s\"", pCvar->GetName(), Host_CleanupConVarStringValue( pCvar->GetString() ) ); m_DemoFile.WriteConsoleCommand( cvarcmd, GetRecordingTick() ); } } //----------------------------------------------------------------------------- // Purpose: // Input : *cmdname - //----------------------------------------------------------------------------- void CDemoRecorder::RecordCommand( const char *cmdstring ) { if ( !IsRecording() ) return; if ( !cmdstring || !cmdstring[0] ) return; if ( !demo_recordcommands.GetInt() ) return; m_DemoFile.WriteConsoleCommand( cmdstring, GetRecordingTick() ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CDemoRecorder::StartupDemoHeader( void ) { CloseDemoFile(); // make sure it's closed // Note: this is replacing tmpfile() if ( !m_DemoFile.Open( DEMO_HEADER_FILE, false ) ) { ConDMsg ("ERROR: couldn't open temporary header file.\n"); return; } m_bIsDemoHeader = true; Assert( m_MessageData.GetBasePointer() == NULL ); // setup writing data buffer m_MessageData.StartWriting( new unsigned char[NET_MAX_PAYLOAD], NET_MAX_PAYLOAD ); m_MessageData.SetDebugName( "DemoHeaderWriteBuffer" ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CDemoRecorder::StartupDemoFile( void ) { if ( !m_bRecording ) return; // Already recording!!! if ( m_DemoFile.IsOpen() ) return; char demoFileName[MAX_OSPATH]; if ( m_nDemoNumber <= 1 ) { V_sprintf_safe( demoFileName, "%s.dem", m_szDemoBaseName ); } else { V_sprintf_safe( demoFileName, "%s_%i.dem", m_szDemoBaseName, m_nDemoNumber ); } // strip any trailing whitespace Q_StripPrecedingAndTrailingWhitespace( demoFileName ); // make sure the .dem extension is still present char ext[10]; Q_ExtractFileExtension( demoFileName, ext, sizeof( ext ) ); if ( Q_strcasecmp( ext, "dem" ) ) { ConMsg( "StartupDemoFile: invalid filename.\n" ); return; } if ( !m_DemoFile.Open( demoFileName, false ) ) return; // open demo header file containing sigondata FileHandle_t hDemoHeader = g_pFileSystem->Open( DEMO_HEADER_FILE, "rb" ); if ( hDemoHeader == FILESYSTEM_INVALID_HANDLE ) { ConMsg ("StartupDemoFile: couldn't open demo file header.\n"); return; } Assert( m_MessageData.GetBasePointer() == NULL ); // setup writing data buffer m_MessageData.StartWriting( new unsigned char[NET_MAX_PAYLOAD], NET_MAX_PAYLOAD ); m_MessageData.SetDebugName( "DemoFileWriteBuffer" ); // fill demo header info demoheader_t *dh = &m_DemoFile.m_DemoHeader; Q_memset(dh, 0, sizeof(demoheader_t)); dh->demoprotocol = DEMO_PROTOCOL; dh->networkprotocol = PROTOCOL_VERSION; Q_strncpy(dh->demofilestamp, DEMO_HEADER_ID, sizeof(dh->demofilestamp) ); Q_FileBase( modelloader->GetName( host_state.worldmodel ), dh->mapname, sizeof( dh->mapname ) ); char szGameDir[MAX_OSPATH]; Q_strncpy(szGameDir, com_gamedir, sizeof( szGameDir ) ); Q_FileBase ( szGameDir, dh->gamedirectory, sizeof( dh->gamedirectory ) ); Q_strncpy( dh->servername, cl.m_szRetryAddress, sizeof( dh->servername ) ); Q_strncpy( dh->clientname, cl_name.GetString(), sizeof( dh->clientname ) ); // get size signon data size dh->signonlength = g_pFileSystem->Size(hDemoHeader); // write demo file header info m_DemoFile.WriteDemoHeader(); // copy signon data from header file to demo file m_DemoFile.WriteFileBytes( hDemoHeader, dh->signonlength ); // close but keep header file, we might need it for a second record g_pFileSystem->Close( hDemoHeader ); m_nFrameCount = 0; m_bIsDemoHeader = false; ResyncDemoClock(); // reset demo clock // tell client to sync demo clock too m_DemoFile.WriteCmdHeader( dem_synctick, 0 ); RecordStringTables(); // Demo playback should read this as an incoming message. WriteDemoCvars(); // save all cvars marked with FCVAR_DEMO WriteBSPDecals(); g_ClientDLL->HudReset(); // tell server that we started recording a demo cl.SendStringCmd( "demorestart" ); ConMsg ("Recording to %s...\n", demoFileName); g_ClientDLL->OnDemoRecordStart( m_szDemoBaseName ); } CDemoRecorder::CDemoRecorder() { } CDemoRecorder::~CDemoRecorder() { CloseDemoFile(); } CDemoFile *CDemoRecorder::GetDemoFile() { return &m_DemoFile; } void CDemoRecorder::ResumeRecording() { } void CDemoRecorder::PauseRecording() { } void CDemoRecorder::CloseDemoFile() { if ( m_DemoFile.IsOpen()) { if ( !m_bIsDemoHeader ) { // Demo playback should read this as an incoming message. m_DemoFile.WriteCmdHeader( dem_stop, GetRecordingTick() ); // update demo header infos m_DemoFile.m_DemoHeader.playback_ticks = GetRecordingTick(); m_DemoFile.m_DemoHeader.playback_time = host_state.interval_per_tick * GetRecordingTick(); m_DemoFile.m_DemoHeader.playback_frames = m_nFrameCount; // go back to header and write demoHeader with correct time and #frame again m_DemoFile.WriteDemoHeader(); ConMsg ("Completed demo, recording time %.1f, game frames %i.\n", m_DemoFile.m_DemoHeader.playback_time, m_DemoFile.m_DemoHeader.playback_frames ); } if ( demo_debug.GetInt() ) { ConMsg ("Closed demo file, %i bytes.\n", m_DemoFile.GetSize() ); } m_DemoFile.Close(); g_ClientDLL->OnDemoRecordStop(); } m_bCloseDemoFile = false; m_bIsDemoHeader = false; // clear writing data buffer if ( m_MessageData.GetBasePointer() ) { delete [] m_MessageData.GetBasePointer(); m_MessageData.StartWriting( NULL, 0 ); } } void CDemoRecorder::RecordMessages(bf_read &data, int bits) { if ( m_MessageData.GetBasePointer() && (bits>0) ) { m_MessageData.WriteBitsFromBuffer( &data, bits ); Assert( !m_MessageData.IsOverflowed() ); } } void CDemoRecorder::RecordPacket() { WriteMessages( m_MessageData ); m_MessageData.Reset(); // clear message buffer if ( m_bCloseDemoFile ) { CloseDemoFile(); } } void CDemoRecorder::WriteMessages( bf_write &message ) { int len = message.GetNumBytesWritten(); if (len <= 0) return; // fill last bits in last byte with NOP if necessary int nRemainingBits = message.GetNumBitsWritten() % 8; if ( nRemainingBits > 0 && nRemainingBits <= (8-NETMSG_TYPE_BITS) ) { message.WriteUBitLong( net_NOP, NETMSG_TYPE_BITS ); } Assert( len < NET_MAX_MESSAGE ); // if signondata read as fast as possible, no rewind // and wait for packet time unsigned char cmd = m_bIsDemoHeader ? dem_signon : dem_packet; if ( cmd == dem_packet ) { m_nFrameCount++; } // write command & time m_DemoFile.WriteCmdHeader( cmd, GetRecordingTick() ); democmdinfo_t info; // Snag current info GetClientCmdInfo( info ); // Store it m_DemoFile.WriteCmdInfo( info ); // write network channel sequencing infos int nOutSequenceNr, nInSequenceNr, nOutSequenceNrAck; cl.m_NetChannel->GetSequenceData( nOutSequenceNr, nInSequenceNr, nOutSequenceNrAck ); m_DemoFile.WriteSequenceInfo( nInSequenceNr, nOutSequenceNrAck ); // Output the messge buffer. m_DemoFile.WriteRawData( (char*) message.GetBasePointer(), len ); if ( demo_debug.GetInt() >= 1 ) { Msg( "Writing demo message %i bytes at file pos %i\n", len, m_DemoFile.GetCurPos( false ) ); } } //----------------------------------------------------------------------------- // Purpose: stop recording a demo //----------------------------------------------------------------------------- void CDemoRecorder::StopRecording( void ) { if ( !IsRecording() ) { return; } if ( m_MessageData.GetBasePointer() ) { delete[] m_MessageData.GetBasePointer(); m_MessageData.StartWriting( NULL, 0); } CloseDemoFile(); m_bRecording = false; m_nDemoNumber = 0; g_DemoOverlay.Tick(); } //----------------------------------------------------------------------------- // Purpose: // Input : *name - // track - //----------------------------------------------------------------------------- void CDemoRecorder::StartRecording( const char *name, bool bContinuously ) { Q_strncpy( m_szDemoBaseName, name, sizeof(m_szDemoBaseName)); m_bRecording = true; m_nDemoNumber = 1; m_bResetInterpolation = false; g_DemoOverlay.Tick(); // request a full game update from server cl.ForceFullUpdate(); } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CDemoRecorder::IsRecording( void ) { g_DemoOverlay.Tick(); return m_bRecording; } //----------------------------------------------------------------------------- // Purpose: Called when a demo file runs out, or the user starts a game // Output : void CDemo::StopPlayback //----------------------------------------------------------------------------- void CDemoPlayer::StopPlayback( void ) { if ( !IsPlayingBack() ) return; demoaction->StopPlaying(); m_DemoFile.Close(); m_bPlayingBack = false; m_bLoading = false; m_bPlaybackPaused = false; m_flAutoResumeTime = 0.0f; m_nEndTick = 0; if ( m_bTimeDemo ) { g_EngineStats.EndRun(); if ( !s_bBenchframe ) { WriteTimeDemoResults(); } else { mat_norendering.SetValue( 0 ); } m_bTimeDemo = false; } else { int framecount = host_framecount - m_nTimeDemoStartFrame; float demotime = Sys_FloatTime() - m_flTimeDemoStartTime; if ( demotime > 0.0f ) { DevMsg( "Demo playback finished ( %.1f seconds, %i render frames, %.2f fps).\n", demotime, framecount, framecount/demotime); } } m_flPlaybackRateModifier = 1.0f; delete[] m_DemoPacket.data; m_DemoPacket.data = NULL; scr_demo_override_fov = 0.0f; if ( timedemo_runcount.GetInt() > 1 ) { timedemo_runcount.SetValue( timedemo_runcount.GetInt() - 1 ); Cbuf_AddText( va( "timedemo %s", m_DemoFile.m_szFileName ) ); } else if ( demo_quitafterplayback.GetBool() ) { Cbuf_AddText( "quit\n" ); } g_ClientDLL->OnDemoPlaybackStop(); } CDemoFile *CDemoPlayer::GetDemoFile( void ) { return &m_DemoFile; } #define SKIP_TO_TICK_FLAG uint32( uint32( 0x88 ) << 24 ) bool CDemoPlayer::IsSkipping( void ) { return m_bPlayingBack && ( m_nSkipToTick != -1 ); } bool CDemoPlayer::IsLoading( void ) { return m_bLoading; } int CDemoPlayer::GetTotalTicks(void) { return m_DemoFile.m_DemoHeader.playback_ticks; } void CDemoPlayer::SkipToTick( int tick, bool bRelative, bool bPause ) { if ( bRelative ) { tick = GetPlaybackTick() + tick; } if ( tick < 0 ) return; if ( tick < GetPlaybackTick() ) { // we have to reload the whole demo file // we need to create a temp copy of the filename char fileName[MAX_OSPATH]; Q_strncpy( fileName, m_DemoFile.m_szFileName, sizeof(fileName) ); // reload current demo file ETWMarkPrintf( "DemoPlayer: Reloading demo file '%s'", fileName ); StartPlayback( fileName, m_bTimeDemo ); // Make sure the proper skipping occurs after reload if ( tick > 0 ) tick |= SKIP_TO_TICK_FLAG; } m_nSkipToTick = tick; ETWMark1I( "DemoPlayer: SkipToTick", tick ); if ( bPause ) PausePlayback( -1 ); } void CDemoPlayer::SetEndTick( int tick ) { if ( tick < 0 ) return; m_nEndTick = tick; } //----------------------------------------------------------------------------- // Purpose: Read in next demo message and send to local client over network channel, if it's time. // Output : bool //----------------------------------------------------------------------------- bool CDemoPlayer::ParseAheadForInterval( int curtick, int intervalticks ) { int tick = 0; int dummy; byte cmd = dem_stop; democmdinfo_t nextinfo; long starting_position = m_DemoFile.GetCurPos( true ); // remove all entrys older than 32 ticks while ( m_DestCmdInfo.Count() > 0 ) { DemoCommandQueue& entry = m_DestCmdInfo[ 0 ]; if ( entry.tick >= (curtick - 32) ) break; if ( entry.filepos >= starting_position ) break; m_DestCmdInfo.Remove( 0 ); } if ( m_bTimeDemo ) return false; while ( true ) { // skip forward to the next dem_packet or dem_signon bool swallowmessages = true; do { m_DemoFile.ReadCmdHeader( cmd, tick ); // COMMAND HANDLERS switch ( cmd ) { case dem_synctick: case dem_stop: { m_DemoFile.SeekTo( starting_position, true ); return false; } break; case dem_consolecmd: { m_DemoFile.ReadConsoleCommand(); } break; case dem_datatables: { m_DemoFile.ReadNetworkDataTables( NULL ); } break; case dem_usercmd: { m_DemoFile.ReadUserCmd( NULL, dummy ); } break; case dem_stringtables: { m_DemoFile.ReadStringTables( NULL ); } break; default: { swallowmessages = false; } break; } } while ( swallowmessages ); int curpos = m_DemoFile.GetCurPos( true ); // we read now a dem_packet m_DemoFile.ReadCmdInfo( nextinfo ); m_DemoFile.ReadSequenceInfo( dummy, dummy ); m_DemoFile.ReadRawData( NULL, 0 ); DemoCommandQueue entry; entry.info = nextinfo; entry.tick = tick; entry.filepos = curpos; int i = 0; int c = m_DestCmdInfo.Count(); for ( ; i < c; ++i ) { if ( m_DestCmdInfo[ i ].filepos == entry.filepos ) break; // cmdinfo is already in list } if ( i >= c ) { // add cmdinfo to list if ( c > 0 ) { if ( m_DestCmdInfo[ c - 1 ].tick > tick ) { m_DestCmdInfo.RemoveAll(); } } m_DestCmdInfo.AddToTail( entry ); } if ( ( tick - curtick ) > intervalticks ) break; } m_DemoFile.SeekTo( starting_position, true ); return true; } //----------------------------------------------------------------------------- // Purpose: Read in next demo message and send to local client over network channel, if it's time. // Output : netpacket_t* -- NULL if there is no packet available at this time. //----------------------------------------------------------------------------- netpacket_t *CDemoPlayer::ReadPacket( void ) { int tick = 0; byte cmd = dem_signon; long curpos = 0; if ( ! m_DemoFile.IsOpen() ) { m_bPlayingBack = false; Host_EndGame( true, "Tried to read a demo message with no demo file\n" ); return NULL; } // If game is still shutting down, then don't read any demo messages from file quite yet if ( HostState_IsGameShuttingDown() ) { return NULL; } Assert( IsPlayingBack() ); if ( IsSkipping() ) { // Every nMaxConsecutiveSkipPackets frames return NULL so that we don't build up an // endless supply of unprocessed packets. This avoids causing overflows and excessive // "highwater marks" in various Dota subsystems. ++m_nSkipPacketsPlayed; if ( m_nSkipPacketsPlayed >= nMaxConsecutiveSkipPackets ) { m_nSkipPacketsPlayed = 0; return NULL; } } else { m_nSkipPacketsPlayed = 0; } // External editor has paused playback if ( CheckPausedPlayback() ) return NULL; bool bStopReading = false; while ( !bStopReading ) { curpos = m_DemoFile.GetCurPos( true ); m_DemoFile.ReadCmdHeader( cmd, tick ); // always read control commands if ( !IsControlCommand( cmd ) ) { int playbacktick = GetPlaybackTick(); #if defined( RAD_TELEMETRY_ENABLED ) g_Telemetry.playbacktick = playbacktick; #endif // If the end tick is set, check to see if we should bail if ( m_nEndTick > 0 && playbacktick >= m_nEndTick ) { m_nEndTick = 0; return NULL; } if ( !m_bTimeDemo ) { // Time demo ignores clocks and tries to synchronize frames to what was recorded // I.e., while frame is the same, read messages, otherwise, skip out. // If we're still signing on, then just parse messages until fully connected no matter what if ( cl.IsActive() && (tick > playbacktick) && !IsSkipping() ) { // is not time yet bStopReading = true; } } else { if ( m_nTimeDemoCurrentFrame == host_framecount ) { // If we are playing back a timedemo, and we've already passed on a // frame update for this host_frame tag, then we'll just skip this mess bStopReading = true; } } if ( bStopReading ) { demoaction->Update( false, playbacktick, TICKS_TO_TIME( playbacktick ) ); m_DemoFile.SeekTo( curpos, true ); // go back to start of current demo command return NULL; // Not time yet, dont return packet data. } } // COMMAND HANDLERS switch ( cmd ) { case dem_synctick: { if ( demo_debug.GetBool() ) { Msg( "%d dem_synctick\n", tick ); } ResyncDemoClock(); // Once demo clock got resync-ed we can go ahead and // perform skipping logic normally if ( ( m_nSkipToTick != -1 ) && ( ( m_nSkipToTick & SKIP_TO_TICK_FLAG ) == SKIP_TO_TICK_FLAG ) ) { m_nSkipToTick &= ~SKIP_TO_TICK_FLAG; } } break; case dem_stop: { if ( demo_debug.GetBool() ) { Msg( "%d dem_stop\n", tick ); } OnStopCommand(); return NULL; } break; case dem_consolecmd: { const char * command = m_DemoFile.ReadConsoleCommand(); if ( demo_debug.GetBool() ) { Msg( "%d dem_consolecmd [%s]\n", tick, command ); } Cbuf_AddText( command ); Cbuf_Execute(); } break; case dem_datatables: { if ( demo_debug.GetBool() ) { Msg( "%d dem_datatables\n", tick ); } void *data = malloc( 256*1024 ); // X360TBD: How much memory is really needed here? bf_read buf( "dem_datatables", data, 256*1024 ); m_DemoFile.ReadNetworkDataTables( &buf ); buf.Seek( 0 ); // re-read data // support for older engine demos if ( !DataTable_LoadDataTablesFromBuffer( &buf, m_DemoFile.m_DemoHeader.demoprotocol ) ) { Host_Error( "Error parsing network data tables during demo playback." ); } free( data ); } break; case dem_stringtables: { void *data = NULL; int dataLen = 512 * 1024; while ( dataLen <= DEMO_FILE_MAX_STRINGTABLE_SIZE ) { data = realloc( data, dataLen ); bf_read buf( "dem_stringtables", data, dataLen ); // did we successfully read if ( m_DemoFile.ReadStringTables( &buf ) > 0 ) { buf.Seek( 0 ); if ( !networkStringTableContainerClient->ReadStringTables( buf ) ) { Host_Error( "Error parsing string tables during demo playback." ); } break; } // Didn't fit. Try doubling the size of the buffer dataLen *= 2; } if ( dataLen > DEMO_FILE_MAX_STRINGTABLE_SIZE ) { Warning( "ReadPacket failed to read string tables. Trying to read string tables that's bigger than max string table size\n" ); } free( data ); } break; case dem_usercmd: { if ( demo_debug.GetBool() ) { Msg( "%d dem_usercmd\n", tick ); } char buffer[256]; int length = sizeof(buffer); int outgoing_sequence = m_DemoFile.ReadUserCmd( buffer, length ); // put it into a bitbuffer bf_read msg( "CDemo::ReadUserCmd", buffer, length ); g_ClientDLL->DecodeUserCmdFromBuffer( msg, outgoing_sequence ); // Note, we need to have the current outgoing sequence correct so we can do prediction // correctly during playback cl.lastoutgoingcommand = outgoing_sequence; } break; default: { bStopReading = true; if ( IsSkipping() ) { // adjust playback host_tickcount when skipping m_nStartTick = host_tickcount - tick; } } break; } } if ( cmd == dem_packet ) { // remember last frame we read a dem_packet update m_nTimeDemoCurrentFrame = host_framecount; } int inseq, outseqack, outseq = 0; m_DemoFile.ReadCmdInfo( m_LastCmdInfo ); m_DemoFile.ReadSequenceInfo( inseq, outseqack ); cl.m_NetChannel->SetSequenceData( outseq, inseq, outseqack ); int length = m_DemoFile.ReadRawData( (char*)m_DemoPacket.data, NET_MAX_PAYLOAD ); if ( demo_debug.GetBool() ) { Msg( "%d network packet [%d]\n", tick, length ); } if ( length > 0 ) { // succsessfully read new demopacket m_DemoPacket.received = realtime; m_DemoPacket.size = length; m_DemoPacket.message.StartReading( m_DemoPacket.data, m_DemoPacket.size ); if ( demo_debug.GetInt() >= 1 ) { Msg( "Demo message, tick %i, %i bytes\n", GetPlaybackTick(), length ); } } // Try and jump ahead one frame m_bInterpolateView = ParseAheadForInterval( tick, 8 ); // ConMsg( "Reading message for %i : %f skip %i\n", m_nFrameCount, fElapsedTime, forceskip ? 1 : 0 ); // Skip a few ticks before doing any timing if ( (m_nTimeDemoStartFrame < 0) && GetPlaybackTick() > 100 ) { m_nTimeDemoStartFrame = host_framecount; m_flTimeDemoStartTime = Sys_FloatTime(); m_flTotalFPSVariability = 0.0f; if ( m_bTimeDemo ) { g_EngineStats.BeginRun(); } } if ( m_nSnapshotTick > 0 && m_nSnapshotTick <= GetPlaybackTick() ) { const char *filename = "benchframe"; if ( m_SnapshotFilename[0] ) filename = m_SnapshotFilename; CL_TakeScreenshot( filename ); // take a screenshot m_nSnapshotTick = 0; if ( s_bBenchframe ) { Cbuf_AddText( "stopdemo\n" ); } } return &m_DemoPacket; } void CDemoPlayer::InterpolateDemoCommand( int targettick, DemoCommandQueue& prev, DemoCommandQueue& next ) { CUtlVector< DemoCommandQueue >& list = m_DestCmdInfo; int c = list.Count(); prev.info.Reset(); next.info.Reset(); if ( c < 2 ) { // we need at least two entries to interpolate return; } int i = 0; int savedI = -1; DemoCommandQueue *entry1 = &list[ i ]; DemoCommandQueue *entry2 = &list[ i+1 ]; while ( true ) { if ( (entry1->tick <= targettick) && (entry2->tick > targettick) ) { // Means we hit a FDEMO_NOINTERP along the way to now if ( savedI != -1 ) { prev = list[ savedI ]; next = list[ savedI + 1 ]; } else { prev = *entry1; next = *entry2; } return; } // If any command between the previous target and now has the FDEMO_NOINTERP, we need to stop at the command just before that (entry), so we save off the I // We can't just return since we need to see if we actually get to a spanning pair (though we always should). Also, we only latch this final interp spot on /// the first FDEMO_NOINTERP we see if ( savedI == -1 && entry2->tick > m_nPreviousTick && entry2->tick <= targettick && entry2->info.flags & FDEMO_NOINTERP ) { savedI = i; } if ( i+2 == c ) break; i++; entry1 = &list[ i ]; entry2 = &list[ i+1 ]; } Assert( 0 ); } static ConVar demo_legacy_rollback( "demo_legacy_rollback", "1", 0, "Use legacy view interpolation rollback amount in demo playback." ); //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CDemoPlayer::InterpolateViewpoint( void ) { if ( !IsPlayingBack() ) return; democmdinfo_t outinfo; outinfo.Reset(); bool bHasValidData = m_LastCmdInfo.viewOrigin != vec3_origin || m_LastCmdInfo.viewAngles != vec3_angle || m_LastCmdInfo.localViewAngles != vec3_angle || m_LastCmdInfo.flags != 0; int nTargetTick = GetPlaybackTick(); // Player view needs to be one tick interval in the past like the client DLL entities if ( cl.m_nMaxClients == 1 ) { if ( demo_legacy_rollback.GetBool() ) { nTargetTick -= TIME_TO_TICKS( cl.GetClientInterpAmount() ) + 1; } else { nTargetTick -= 1; } } float vel = 0.0f; float angVel = 0.0f; if ( m_bInterpolateView && demo_interpolateview.GetBool() && bHasValidData ) { DemoCommandQueue prev, next; float frac = 0.0f; prev.info = m_LastCmdInfo; prev.tick = -1; next.info = m_LastCmdInfo; next.tick = -1; // Determine current time slice InterpolateDemoCommand( nTargetTick, prev, next ); float dt = TICKS_TO_TIME(next.tick-prev.tick); frac = (TICKS_TO_TIME(nTargetTick-prev.tick)+cl.m_tickRemainder)/dt; frac = clamp( frac, 0.0f, 1.0f ); // Now interpolate Vector delta; Vector startorigin = prev.info.GetViewOrigin(); Vector destorigin = next.info.GetViewOrigin(); // check for teleporting - since there can be multiple cmd packets between a game frame, // we need to check from the last actually ran command to see if there was a teleport VectorSubtract( destorigin, m_LastCmdInfo.GetViewOrigin(), delta ); float distmoved = delta.Length(); if ( dt > 0.0f ) { vel = distmoved / dt; } if ( dt > 0.0f ) { QAngle startang = prev.info.GetLocalViewAngles(); QAngle destang = next.info.GetLocalViewAngles(); for ( int i = 0; i < 3; ++i ) { float dAng = AngleNormalizePositive( destang[ i ] ) - AngleNormalizePositive( startang[ i ] ); dAng = AngleNormalize( dAng ); float aVel = fabs( dAng ) / dt; if ( aVel > angVel ) { angVel = aVel; } } } // FIXME: This should be velocity based maybe? if ( (vel > demo_interplimit.GetFloat()) || (angVel > demo_avellimit.GetFloat() ) || m_bResetInterpolation ) { m_bResetInterpolation = false; // it's a teleport, just let it happen naturally next frame // setting frac to 1.0 (like it was previously) would just mean that we // are teleporting a frame ahead of when we should outinfo.viewOrigin = m_LastCmdInfo.GetViewOrigin(); outinfo.viewAngles = m_LastCmdInfo.GetViewAngles(); outinfo.localViewAngles = m_LastCmdInfo.GetLocalViewAngles(); } else { outinfo.viewOrigin = startorigin + frac * ( destorigin - startorigin ); Quaternion src, dest; Quaternion result; AngleQuaternion( prev.info.GetViewAngles(), src ); AngleQuaternion( next.info.GetViewAngles(), dest ); QuaternionSlerp( src, dest, frac, result ); QuaternionAngles( result, outinfo.viewAngles ); AngleQuaternion( prev.info.GetLocalViewAngles(), src ); AngleQuaternion( next.info.GetLocalViewAngles(), dest ); QuaternionSlerp( src, dest, frac, result ); QuaternionAngles( result, outinfo.localViewAngles ); } } else if ( bHasValidData ) { // don't interpolate, just copy values outinfo.viewOrigin = m_LastCmdInfo.GetViewOrigin(); outinfo.viewAngles = m_LastCmdInfo.GetViewAngles(); outinfo.localViewAngles = m_LastCmdInfo.GetLocalViewAngles(); } m_nPreviousTick = nTargetTick; // let any demo system override view ( drive, editor, smoother etc) bHasValidData |= OverrideView( outinfo ); if ( !bHasValidData ) return; // no validate data & no override, exit g_pClientSidePrediction->SetViewOrigin( outinfo.viewOrigin ); g_pClientSidePrediction->SetViewAngles( outinfo.viewAngles ); g_pClientSidePrediction->SetLocalViewAngles( outinfo.localViewAngles ); #ifndef SWDS VectorCopy( outinfo.viewAngles, cl.viewangles ); #endif } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CDemoPlayer::IsPlayingTimeDemo( void ) { return m_bTimeDemo && m_bPlayingBack; } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CDemoPlayer::IsPlayingBack( void ) { return m_bPlayingBack; } CDemoPlayer::CDemoPlayer() { m_flAutoResumeTime = 0.0f; m_flPlaybackRateModifier = 1.0f; m_bTimeDemo = false; m_nTimeDemoStartFrame = -1; m_flTimeDemoStartTime = 0.0f; m_flTotalFPSVariability = 0.0f; m_nTimeDemoCurrentFrame = -1; m_bPlayingBack = false; m_bLoading = false; m_bPlaybackPaused = false; m_nSkipToTick = -1; m_nSkipPacketsPlayed = 0; m_nSnapshotTick = 0; m_SnapshotFilename[0] = 0; m_bResetInterpolation = false; m_nPreviousTick = 0; m_nEndTick = 0; } CDemoPlayer::~CDemoPlayer() { StopPlayback(); if ( g_ClientDLL ) { g_ClientDLL->OnDemoPlaybackStop(); } } //----------------------------------------------------------------------------- // Purpose: Start's demo playback // Input : *name - //----------------------------------------------------------------------------- bool CDemoPlayer::StartPlayback( const char *filename, bool bAsTimeDemo ) { m_bLoading = true; SCR_BeginLoadingPlaque(); // Disconnect from server or stop running one int oldn = cl.demonum; cl.demonum = -1; Host_Disconnect(false); cl.demonum = oldn; if ( !m_DemoFile.Open( filename, true ) ) { cl.demonum = -1; // stop demo loop return false; } // Read in the m_DemoHeader demoheader_t *dh = m_DemoFile.ReadDemoHeader(); if ( !dh ) { ConMsg( "Failed to read demo header.\n" ); m_DemoFile.Close(); cl.demonum = -1; return false; } ConMsg ("Playing demo from %s.\n", filename); // Now read in the directory structure. m_bPlayingBack = true; cl.m_nSignonState= SIGNONSTATE_CONNECTED; ResyncDemoClock(); // create a fake channel with a NULL address cl.m_NetChannel = NET_CreateNetChannel( NS_CLIENT, NULL, "DEMO", &cl, false, dh->networkprotocol ); if ( !cl.m_NetChannel ) { ConMsg ("CDemo::Play: failed to create demo net channel\n" ); m_DemoFile.Close(); cl.demonum = -1; // stop demo loop Host_Disconnect(true); } cl.m_NetChannel->SetTimeout( -1.0f ); // never timeout Q_memset( &m_DemoPacket, 0, sizeof(m_DemoPacket) ); // setup demo packet data buffer m_DemoPacket.data = new unsigned char[NET_MAX_PAYLOAD]; m_DemoPacket.from.SetType( NA_LOOPBACK); cl.chokedcommands = 0; cl.lastoutgoingcommand = -1; cl.m_flNextCmdTime = net_time; m_bTimeDemo = bAsTimeDemo; m_nTimeDemoCurrentFrame = -1; m_nTimeDemoStartFrame = -1; if ( m_bTimeDemo ) { SeedRandomNumberGenerator( true ); } demoaction->StartPlaying( filename ); // m_bFastForwarding = false; m_flAutoResumeTime = 0.0f; m_flPlaybackRateModifier = 1.0f; scr_demo_override_fov = 0.0f; m_bLoading = false; return true; } //----------------------------------------------------------------------------- // Purpose: // Input : flCurTime - //----------------------------------------------------------------------------- void CDemoPlayer::MarkFrame( float flFPSVariability ) { m_flTotalFPSVariability += flFPSVariability; } void CDemoPlayer::WriteTimeDemoResults( void ) { int frames; float time; frames = (host_framecount - m_nTimeDemoStartFrame) - 1; time = Sys_FloatTime() - m_flTimeDemoStartTime; if (!time) { time = 1; } float flVariability = (m_flTotalFPSVariability / (float)frames); ConMsg ("%i frames %5.3f seconds %5.2f fps (%5.2f ms/f) %5.3f fps variability\n", frames, time, frames/time, 1000*time/frames, flVariability ); bool bFileExists = g_pFileSystem->FileExists( "SourceBench.csv" ); FileHandle_t fileHandle = g_pFileSystem->Open( "SourceBench.csv", "a+" ); int width, height; CMatRenderContextPtr pRenderContext( materials ); pRenderContext->GetWindowSize( width, height ); const MaterialSystem_Config_t &config = materials->GetCurrentConfigForVideoCard(); if( !bFileExists ) { g_pFileSystem->FPrintf( fileHandle, "demofile," ); g_pFileSystem->FPrintf( fileHandle, "fps," ); g_pFileSystem->FPrintf( fileHandle, "framerate variability," ); g_pFileSystem->FPrintf( fileHandle, "totaltime," ); g_pFileSystem->FPrintf( fileHandle, "numframes," ); g_pFileSystem->FPrintf( fileHandle, "width," ); g_pFileSystem->FPrintf( fileHandle, "height," ); g_pFileSystem->FPrintf( fileHandle, "windowed," ); g_pFileSystem->FPrintf( fileHandle, "vsync," ); g_pFileSystem->FPrintf( fileHandle, "MSAA," ); g_pFileSystem->FPrintf( fileHandle, "Aniso," ); g_pFileSystem->FPrintf( fileHandle, "dxlevel," ); g_pFileSystem->FPrintf( fileHandle, "cmdline," ); g_pFileSystem->FPrintf( fileHandle, "driver name," ); g_pFileSystem->FPrintf( fileHandle, "vendor id," ); g_pFileSystem->FPrintf( fileHandle, "device id," ); // g_pFileSystem->FPrintf( fileHandle, "sound," ); g_pFileSystem->FPrintf( fileHandle, "Reduce fillrate," ); g_pFileSystem->FPrintf( fileHandle, "reflect entities," ); g_pFileSystem->FPrintf( fileHandle, "motion blur," ); g_pFileSystem->FPrintf( fileHandle, "flashlight shadows," ); g_pFileSystem->FPrintf( fileHandle, "mat_reduceparticles," ); g_pFileSystem->FPrintf( fileHandle, "r_dopixelvisibility," ); g_pFileSystem->FPrintf( fileHandle, "nulldevice," ); g_pFileSystem->FPrintf( fileHandle, "timedemo_comment," ); g_pFileSystem->FPrintf( fileHandle, "\n" ); } ConVarRef mat_vsync( "mat_vsync" ); ConVarRef mat_antialias( "mat_antialias" ); ConVarRef mat_forceaniso( "mat_forceaniso" ); ConVarRef r_waterforcereflectentities( "r_waterforcereflectentities" ); ConVarRef mat_motion_blur_enabled( "mat_motion_blur_enabled" ); ConVarRef r_flashlightdepthtexture( "r_flashlightdepthtexture" ); ConVarRef mat_reducefillrate( "mat_reducefillrate" ); ConVarRef mat_reduceparticles( "mat_reduceparticles" ); ConVarRef r_dopixelvisibility( "r_dopixelvisibility" ); g_pFileSystem->Seek( fileHandle, 0, FILESYSTEM_SEEK_TAIL ); MaterialAdapterInfo_t info; materials->GetDisplayAdapterInfo( materials->GetCurrentAdapter(), info ); g_pFileSystem->FPrintf( fileHandle, "%s,", m_DemoFile.m_szFileName ); g_pFileSystem->FPrintf( fileHandle, "%5.1f,", frames/time ); g_pFileSystem->FPrintf( fileHandle, "%5.1f,", flVariability ); g_pFileSystem->FPrintf( fileHandle, "%5.1f,", time ); g_pFileSystem->FPrintf( fileHandle, "%i,", frames ); g_pFileSystem->FPrintf( fileHandle, "%i,", width ); g_pFileSystem->FPrintf( fileHandle, "%i,", height ); g_pFileSystem->FPrintf( fileHandle, "%s,", config.Windowed() ? "windowed" : "fullscreen"); g_pFileSystem->FPrintf( fileHandle, "%s,", mat_vsync.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%d,", mat_antialias.GetInt() ); g_pFileSystem->FPrintf( fileHandle, "%d,", mat_forceaniso.GetInt() ); g_pFileSystem->FPrintf( fileHandle, "%s,", COM_DXLevelToString( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() ) ); g_pFileSystem->FPrintf( fileHandle, "%s,", CommandLine()->GetCmdLine() ); g_pFileSystem->FPrintf( fileHandle, "%s,", info.m_pDriverName ); g_pFileSystem->FPrintf( fileHandle, "0x%x,", info.m_VendorID ); g_pFileSystem->FPrintf( fileHandle, "0x%x,", info.m_DeviceID ); // g_pFileSystem->FPrintf( fileHandle, "%s,", CommandLine()->CheckParm( "-nosound" ) ? "off" : "on" ); g_pFileSystem->FPrintf( fileHandle, "%s,", mat_reducefillrate.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%s,", r_waterforcereflectentities.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%s,", mat_motion_blur_enabled.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%s,", r_flashlightdepthtexture.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%s,", mat_reduceparticles.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%s,", r_dopixelvisibility.GetBool() ? "on" : "off" ); g_pFileSystem->FPrintf( fileHandle, "%s,", CommandLine()->CheckParm( "-nulldevice" ) ? "yes" : "no" ); int itimedemo_comment = CommandLine()->FindParm( "-timedemo_comment" ); const char *timedemo_comment = itimedemo_comment ? CommandLine()->GetParm( itimedemo_comment + 1 ) : ""; g_pFileSystem->FPrintf( fileHandle, "%s,", timedemo_comment ); g_pFileSystem->FPrintf( fileHandle, "\n" ); g_pFileSystem->Close( fileHandle ); } void CDemoPlayer::PausePlayback( float seconds ) { m_bPlaybackPaused = true; if ( seconds > 0.0f ) { // Use true clock since everything else is frozen m_flAutoResumeTime = Sys_FloatTime() + seconds; } else { m_flAutoResumeTime = 0.0f; } } void CDemoPlayer::ResumePlayback() { m_bPlaybackPaused = false; m_flAutoResumeTime = 0.0f; } bool CDemoPlayer::CheckPausedPlayback() { if ( demo_pauseatservertick.GetInt() > 0 ) { if ( cl.GetServerTickCount() >= demo_pauseatservertick.GetInt() ) { PausePlayback( -1 ); ETWMark1I( "DemoPlayer: Reached pause tick", cl.GetServerTickCount() ); m_nSkipToTick = -1; demo_pauseatservertick.SetValue( 0 ); Msg( "Demo paused at server tick %i\n", cl.GetServerTickCount() ); } } if ( IsSkipping() ) { if ( ( m_nSkipToTick > GetPlaybackTick() ) || ( ( m_nSkipToTick & SKIP_TO_TICK_FLAG ) == SKIP_TO_TICK_FLAG ) ) { // we are skipping return false; } else { // we can't skip back (or finished skipping), so disable skipping ETWMark1I( "DemoPlayer: SkipToTick done", GetPlaybackTick() ); m_nSkipToTick = -1; } } if ( !IsPlaybackPaused() ) return false; if ( m_bPlaybackPaused ) { if ( (m_flAutoResumeTime > 0.0f) && (Sys_FloatTime() >= m_flAutoResumeTime) ) { // it's time to unpause replay ResumePlayback(); } } return m_bPlaybackPaused; } bool CDemoPlayer::IsPlaybackPaused() { if ( !IsPlayingBack() ) return false; // never pause while reading signon data if ( m_nTimeDemoCurrentFrame < 0 ) return false; // If skipping then do not pretend paused if ( IsSkipping() ) return false; return m_bPlaybackPaused; } int CDemoPlayer::GetPlaybackStartTick( void ) { return m_nStartTick; } int CDemoPlayer::GetPlaybackTick( void ) { return host_tickcount - m_nStartTick; } void CDemoPlayer::ResyncDemoClock() { m_nStartTick = host_tickcount; m_nPreviousTick = m_nStartTick; } float CDemoPlayer::GetPlaybackTimeScale() { return m_flPlaybackRateModifier; } void CDemoPlayer::SetPlaybackTimeScale(float timescale) { m_flPlaybackRateModifier = timescale; } void CDemoPlayer::SetBenchframe( int tick, const char *filename ) { m_nSnapshotTick = tick; if ( filename ) { Q_strncpy( m_SnapshotFilename, filename, sizeof(m_SnapshotFilename) ); } } static bool ComputeNextIncrementalDemoFilename( char *name, int namesize ) { FileHandle_t test; test = g_pFileSystem->Open( name, "rb" ); if ( FILESYSTEM_INVALID_HANDLE == test ) { // file doesn't exist, so we can use that return true; } g_pFileSystem->Close( test ); char basename[ MAX_OSPATH ]; Q_StripExtension( name, basename, sizeof( basename ) ); // Start looking for a valid name int i = 0; for ( i = 0; i < 1000; i++ ) { char newname[ MAX_OSPATH ]; Q_snprintf( newname, sizeof( newname ), "%s%03i.dem", basename, i ); test = g_pFileSystem->Open( newname, "rb" ); if ( FILESYSTEM_INVALID_HANDLE == test ) { Q_strncpy( name, newname, namesize ); return true; } g_pFileSystem->Close( test ); } ConMsg( "Unable to find a valid incremental demo filename for %s, try clearing the directory of %snnn.dem\n", name, basename ); return false; } //----------------------------------------------------------------------------- // Purpose: List the contents of a demo file. //----------------------------------------------------------------------------- void CL_ListDemo_f( const CCommand &args ) { if ( cmd_source != src_command ) return; // Find the file char name[MAX_OSPATH]; Q_snprintf (name, sizeof(name), "%s", args[1]); Q_DefaultExtension( name, ".dem", sizeof( name ) ); ConMsg ("Demo contents for %s:\n", name); CDemoFile demofile; if ( !demofile.Open( name, true ) ) { ConMsg ("ERROR: couldn't open.\n"); return; } demofile.ReadDemoHeader(); demoheader_t *header = &demofile.m_DemoHeader; if ( !header ) { ConMsg( "Failed reading demo header.\n" ); demofile.Close(); return; } if ( Q_strcmp ( header->demofilestamp, DEMO_HEADER_ID ) ) { ConMsg( "%s is not a valid demo file\n", name); return; } ConMsg("Network protocol: %i\n", header->networkprotocol); ConMsg("Demo version : %i\n", header->demoprotocol); ConMsg("Server name : %s\n", header->servername); ConMsg("Map name : %s\n", header->mapname); ConMsg("Game : %s\n", header->gamedirectory); ConMsg("Player name : %s\n", header->clientname); ConMsg("Time : %.1f\n", header->playback_time); ConMsg("Ticks : %i\n", header->playback_ticks); ConMsg("Frames : %i\n", header->playback_frames); ConMsg("Signon size : %i\n", header->signonlength); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CON_COMMAND( stop, "Finish recording demo." ) { if ( cmd_source != src_command ) return; if ( !demorecorder->IsRecording() ) { ConDMsg ("Not recording a demo.\n"); return; } demorecorder->StopRecording(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CON_COMMAND_F( record, "Record a demo.", FCVAR_DONTRECORD ) { if ( g_ClientDLL == NULL ) { ConMsg ("Can't record on dedicated server.\n"); return; } if ( args.ArgC() != 2 && args.ArgC() != 3 ) { ConMsg ("record [incremental]\n"); return; } bool incremental = false; if ( args.ArgC() == 3 ) { if ( !Q_stricmp( args[2], "incremental" ) ) { incremental = true; } } if ( demorecorder->IsRecording() ) { ConMsg ("Already recording.\n"); return; } if ( demoplayer->IsPlayingBack() ) { ConMsg ("Can't record during demo playback.\n"); return; } // check path first if ( !COM_IsValidPath( args[1] ) ) { ConMsg( "record %s: invalid path.\n", args[1] ); return; } char name[ MAX_OSPATH ]; if ( !g_ClientDLL->CanRecordDemo( name, sizeof( name ) ) ) { ConMsg( "%s\n", name ); // re-use name as the error string if the client prevents us from starting a demo return; } // remove .dem extension if user added it Q_StripExtension( args[1], name, sizeof( name ) ); if ( incremental ) { // If file exists, construct a better name if ( !ComputeNextIncrementalDemoFilename( name, sizeof( name ) ) ) { return; } } // Record it demorecorder->StartRecording( name, incremental ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CL_PlayDemo_f( const CCommand &args ) { if ( cmd_source != src_command ) return; if ( args.ArgC() != 2 ) { ConMsg ("playdemo : plays a demo file\n"); return; } // Get the demo filename char name[ MAX_OSPATH ]; Q_strncpy( name, args[1], sizeof( name ) ); Q_DefaultExtension( name, ".dem", sizeof( name ) ); // set current demo player to replay demo player? demoplayer = g_pClientDemoPlayer; // // open the demo file // if ( demoplayer->StartPlayback( name, false ) ) { // Remove extension char basename[ MAX_OSPATH ]; V_StripExtension( name, basename, sizeof( basename ) ); g_ClientDLL->OnDemoPlaybackStart( basename ); } else { SCR_EndLoadingPlaque(); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CL_TimeDemo_f( const CCommand &args ) { if ( cmd_source != src_command ) return; if ( args.ArgC() < 2 || args.ArgC() > 4 ) { ConMsg ("timedemo : gets demo speeds, starting from optional frame\n"); return; } if( args.ArgC() >= 3 ) { Q_strncpy( g_pStatsFile, args[ 2 ], sizeof( g_pStatsFile ) ); } else { Q_strncpy( g_pStatsFile, "UNKNOWN", sizeof( g_pStatsFile ) ); } // set current demo player to client demo player demoplayer = g_pClientDemoPlayer; // open the demo file char name[ MAX_OSPATH ]; Q_strncpy (name, args[1], sizeof( name ) ); Q_DefaultExtension( name, ".dem", sizeof( name ) ); if ( !demoplayer->StartPlayback( name, true ) ) { SCR_EndLoadingPlaque(); } } void CL_TimeDemoQuit_f( const CCommand &args ) { demo_quitafterplayback.SetValue( 1 ); CL_TimeDemo_f( args ); } void CL_BenchFrame_f( const CCommand &args ) { if ( cmd_source != src_command ) return; if ( args.ArgC() != 4 ) { ConMsg ("benchframe : takes a snapshot of a particular frame in a demo\n"); return; } g_pClientDemoPlayer->SetBenchframe( max( 0, atoi( args[2] ) ), args[3] ); s_bBenchframe = true; mat_norendering.SetValue( 1 ); // set current demo player to client demo player demoplayer = g_pClientDemoPlayer; // open the demo file char name[ MAX_OSPATH ]; Q_strncpy (name, args[1], sizeof( name ) ); Q_DefaultExtension( name, ".dem", sizeof( name ) ); if ( !demoplayer->StartPlayback( name, true ) ) { SCR_EndLoadingPlaque(); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CON_COMMAND( vtune, "Controls VTune's sampling." ) { if ( args.ArgC() != 2 ) { ConMsg ("vtune \"pause\" | \"resume\" : Suspend or resume VTune's sampling.\n"); return; } if( !Q_strcasecmp( args[1], "pause" ) ) { if(!vtune(false)) { ConMsg("Failed to find \"VTPause()\" in \"vtuneapi.dll\".\n"); return; } ConMsg("VTune sampling paused.\n"); } else if( !Q_strcasecmp( args[1], "resume" ) ) { if(!vtune(true)) { ConMsg("Failed to find \"VTResume()\" in \"vtuneapi.dll\".\n"); return; } ConMsg("VTune sampling resumed.\n"); } else { ConMsg("Unknown vtune option.\n"); } } CON_COMMAND_AUTOCOMPLETEFILE( playdemo, CL_PlayDemo_f, "Play a recorded demo file (.dem ).", NULL, dem ); CON_COMMAND_AUTOCOMPLETEFILE( timedemo, CL_TimeDemo_f, "Play a demo and report performance info.", NULL, dem ); CON_COMMAND_AUTOCOMPLETEFILE( timedemoquit, CL_TimeDemoQuit_f, "Play a demo, report performance info, and then exit", NULL, dem ); CON_COMMAND_AUTOCOMPLETEFILE( listdemo, CL_ListDemo_f, "List demo file contents.", NULL, dem ); CON_COMMAND_AUTOCOMPLETEFILE( benchframe, CL_BenchFrame_f, "Takes a snapshot of a particular frame in a time demo.", NULL, dem ); CON_COMMAND( demo_pause, "Pauses demo playback." ) { float seconds = -1.0; if ( args.ArgC() == 2 ) { seconds = atof( args[1] ); } demoplayer->PausePlayback( seconds ); } CON_COMMAND( demo_resume, "Resumes demo playback." ) { demoplayer->ResumePlayback(); } CON_COMMAND( demo_togglepause, "Toggles demo playback." ) { if ( !demoplayer->IsPlayingBack() ) return; if ( demoplayer->IsPlaybackPaused() ) { demoplayer->ResumePlayback(); } else { demoplayer->PausePlayback( -1 ); } } CON_COMMAND( demo_gototick, "Skips to a tick in demo." ) { bool bRelative = false; bool bPause = false; if ( args.ArgC() < 2 ) { Msg("Syntax: demo_gototick [relative] [pause]\n"); return; } int nTick = atoi( args[1] ); if ( args.ArgC() >= 3 ) { bRelative = Q_atoi( args[2] ) != 0; } if ( args.ArgC() >= 4 ) { bPause = Q_atoi( args[3] ) != 0; } demoplayer->SkipToTick( nTick, bRelative, bPause ); } CON_COMMAND( demo_setendtick, "Sets end demo playback tick. Set to 0 to disable." ) { if ( args.ArgC() != 2 ) { Msg( "Syntax: demo_setendtick \n" ); return; } int nTick = atoi( args[1] ); demoplayer->SetEndTick( nTick ); } CON_COMMAND( demo_timescale, "Sets demo replay speed." ) { float fScale = 1.0f; if ( args.ArgC() == 2 ) { fScale = atof( args[1] ); fScale = clamp( fScale, 0.0f, 100.0f ); } demoplayer->SetPlaybackTimeScale( fScale ); } bool CDemoPlayer::OverrideView( democmdinfo_t& info ) { if ( g_pDemoUI && g_pDemoUI->OverrideView( info, GetPlaybackTick() ) ) return true; if ( g_pDemoUI2 && g_pDemoUI2->OverrideView( info, GetPlaybackTick() ) ) return true; if ( demoaction && demoaction->OverrideView( info, GetPlaybackTick() ) ) return true; return false; } void CDemoPlayer::OnStopCommand() { cl.Disconnect( "Demo stopped", true); } void CDemoPlayer::ResetDemoInterpolation( void ) { m_bResetInterpolation = true; } int CDemoPlayer::GetProtocolVersion() { Assert( IsPlayingBack() ); if ( !IsPlayingBack() ) return PROTOCOL_VERSION; return m_DemoFile.GetProtocolVersion(); }