1HEADmaster

1 files changed, 639 insertions, 0 deletions

diff --git a/game/client/replay/vgui/replaybrowserrenderdialog.cpp b/game/client/replay/vgui/replaybrowserrenderdialog.cpp
new file mode 100644
index 0000000..b3e5972
--- /dev/null
+++ b/game/client/replay/vgui/replaybrowserrenderdialog.cpp
@@ -0,0 +1,639 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#include "cbase.h"
+
+#if defined( REPLAY_ENABLED )
+
+#include "replaybrowserrenderdialog.h"
+#include "vgui_controls/TextImage.h"
+#include "vgui_controls/CheckButton.h"
+#include "vgui_controls/TextEntry.h"
+#include "vgui/IInput.h"
+#include "replay/genericclassbased_replay.h"
+#include "ienginevgui.h"
+#include "replayrenderoverlay.h"
+#include "replay/ireplaymanager.h"
+#include "replay/ireplaymoviemanager.h"
+#include "video/ivideoservices.h"
+#include "confirm_dialog.h"
+#include "replay/replayrenderer.h"
+
+#include "replay/performance.h"
+#include "replay/replayvideo.h"
+#include "replay_gamestats_shared.h"
+
+#include "econ/econ_controls.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+//-----------------------------------------------------------------------------
+
+extern IReplayMovieManager *g_pReplayMovieManager;
+
+//-----------------------------------------------------------------------------
+
+ConVar replay_rendersetting_quitwhendone( "replay_rendersetting_quitwhendone", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Quit after rendering is completed.", true, 0.0f, true, 1.0f );
+ConVar replay_rendersetting_exportraw( "replay_rendersetting_exportraw", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_ARCHIVE, "Export raw TGA frames and a .wav file, instead of encoding a movie file.", true, 0.0f, true, 1.0f );
+ConVar replay_rendersetting_motionblurquality( "replay_rendersetting_motionblurquality", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Motion blur quality.", true, 0, true, MAX_MOTION_BLUR_QUALITY );
+ConVar replay_rendersetting_motionblurenabled( "replay_rendersetting_motionblurenabled", "1", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Motion blur enabled/disabled.", true, 0.0f, true, 1.0f );
+ConVar replay_rendersetting_encodingquality( "replay_rendersetting_encodingquality", "100", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "Render quality: the higher the quality, the larger the resulting movie file size.", true, 0, true, 100 );
+ConVar replay_rendersetting_motionblur_can_toggle( "replay_rendersetting_motionblur_can_toggle", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD, "" );
+ConVar replay_rendersetting_renderglow( "replay_rendersetting_renderglow", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_ARCHIVE, "Glow effect enabled/disabled.", true, 0.0f, true, 1.0f );
+
+//-----------------------------------------------------------------------------
+
+CReplayRenderDialog::CReplayRenderDialog( Panel *pParent, ReplayHandle_t hReplay, bool bSetQuit, int iPerformance )
+:	BaseClass( pParent, "RenderDialog" ),
+	m_bShowAdvancedOptions( false ),
+	m_hReplay( hReplay ),
+	m_bSetQuit( bSetQuit ),
+	m_iPerformance( iPerformance ),
+	m_pVideoModesCombo( NULL ),
+	m_pCodecCombo( NULL ),
+	m_pPlayVoiceCheck( NULL ),
+	m_pShowAdvancedOptionsCheck( NULL ),
+	m_pQuitWhenDoneCheck( NULL ),
+	m_pExportRawCheck( NULL ),
+	m_pTitleText( NULL ),
+	m_pResolutionNoteLabel( NULL ),
+	m_pEnterANameLabel( NULL ),
+	m_pVideoModeLabel( NULL ),
+	m_pCodecLabel( NULL ),
+	m_pMotionBlurLabel( NULL ),
+	m_pMotionBlurSlider( NULL ),
+	m_pQualityLabel( NULL ),
+	m_pQualitySlider( NULL ),
+	m_pTitleLabel( NULL ),
+	m_pCancelButton( NULL ),
+	m_pRenderButton( NULL ),
+	m_pBgPanel( NULL ),
+	m_pMotionBlurCheck( NULL ),
+	m_pQualityPresetLabel( NULL ),
+	m_pQualityPresetCombo( NULL ),
+	m_pSeparator( NULL ),
+	m_pGlowEnabledCheck( NULL )
+{
+	m_iQualityPreset = ReplayVideo_GetDefaultQualityPreset();
+}
+
+void CReplayRenderDialog::UpdateControlsValues()
+{
+	ConVarRef replay_voice_during_playback( "replay_voice_during_playback" );
+
+	m_pQuitWhenDoneCheck->SetSelected( replay_rendersetting_quitwhendone.GetBool() );
+	m_pExportRawCheck->SetSelected( replay_rendersetting_exportraw.GetBool() );
+	m_pShowAdvancedOptionsCheck->SetSelected( m_bShowAdvancedOptions );
+	m_pMotionBlurSlider->SetValue( replay_rendersetting_motionblurquality.GetInt() );
+	m_pMotionBlurCheck->SetSelected( replay_rendersetting_motionblurenabled.GetBool() );
+	m_pQualitySlider->SetValue( replay_rendersetting_encodingquality.GetInt() / ReplayVideo_GetQualityInterval() );
+
+	if ( m_pGlowEnabledCheck )
+	{
+		m_pGlowEnabledCheck->SetSelected( replay_rendersetting_renderglow.GetBool() );
+	}
+
+	if ( replay_voice_during_playback.IsValid() )
+	{
+		m_pPlayVoiceCheck->SetSelected( replay_voice_during_playback.GetBool() );
+	}
+	else
+	{
+		m_pPlayVoiceCheck->SetEnabled( false );
+	}
+}
+
+void CReplayRenderDialog::AddControlToAutoLayout( Panel *pPanel, bool bAdvanced )
+{
+	LayoutInfo_t *pNewLayoutInfo = new LayoutInfo_t;
+	pNewLayoutInfo->pPanel = pPanel;
+
+	// Use the positions from the .res file as relative positions for auto-layout
+	pPanel->GetPos( pNewLayoutInfo->nOffsetX, pNewLayoutInfo->nOffsetY );
+	
+	pNewLayoutInfo->bAdvanced = bAdvanced;
+
+	// Add to the list
+	m_lstControls.AddToTail( pNewLayoutInfo );
+}
+
+void CReplayRenderDialog::SetValuesFromQualityPreset()
+{
+	const ReplayQualityPreset_t &preset = ReplayVideo_GetQualityPreset( m_iQualityPreset );
+	replay_rendersetting_motionblurquality.SetValue( preset.m_iMotionBlurQuality );
+	replay_rendersetting_motionblurenabled.SetValue( (int)preset.m_bMotionBlurEnabled );
+	replay_rendersetting_encodingquality.SetValue( preset.m_iQuality );
+	for ( int i = 0; i < ReplayVideo_GetCodecCount(); ++i )
+	{
+		const ReplayCodec_t &CurCodec = ReplayVideo_GetCodec( i );
+		if ( CurCodec.m_nCodecId == preset.m_nCodecId )
+		{
+			m_pCodecCombo->ActivateItem( m_pCodecCombo->GetItemIDFromRow( i ) );
+			break;
+		}
+	}
+	UpdateControlsValues();
+	InvalidateLayout();
+}
+
+void CReplayRenderDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	int i;
+
+	// Link in TF scheme
+	extern IEngineVGui *enginevgui;
+	vgui::HScheme pTFScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme" );
+	SetScheme( pTFScheme );
+	SetProportional( true );
+
+	BaseClass::ApplySchemeSettings( vgui::scheme()->GetIScheme( pTFScheme ) );
+
+	LoadControlSettings( "Resource/UI/replaybrowser/renderdialog.res", "GAME" );
+
+	// retrieve controls
+	m_pPlayVoiceCheck = dynamic_cast< CheckButton * >( FindChildByName( "PlayVoice" ) );
+	m_pShowAdvancedOptionsCheck = dynamic_cast< CheckButton * >( FindChildByName( "ShowAdvancedOptions" ) );
+	m_pQuitWhenDoneCheck = dynamic_cast< CheckButton * >( FindChildByName( "QuitWhenDone" ) );
+	m_pExportRawCheck = dynamic_cast< CheckButton * >( FindChildByName( "ExportRaw" ) );
+	m_pTitleText = dynamic_cast< TextEntry * >( FindChildByName( "TitleInput" ) );
+	m_pResolutionNoteLabel = dynamic_cast< CExLabel * >( FindChildByName( "ResolutionNoteLabel" ) );
+	m_pEnterANameLabel = dynamic_cast< CExLabel * >( FindChildByName( "EnterANameLabel" ) );
+	m_pVideoModeLabel = dynamic_cast< CExLabel * >( FindChildByName( "VideoModeLabel" ) );
+	m_pCodecLabel = dynamic_cast< CExLabel * >( FindChildByName( "CodecLabel" ) );
+	m_pMotionBlurLabel = dynamic_cast< CExLabel * >( FindChildByName( "MotionBlurLabel" ) );
+	m_pMotionBlurSlider = dynamic_cast< Slider * >( FindChildByName( "MotionBlurSlider" ) );
+	m_pQualityLabel = dynamic_cast< CExLabel * >( FindChildByName( "QualityLabel" ) );
+	m_pQualitySlider = dynamic_cast< Slider * >( FindChildByName( "QualitySlider" ) );
+	m_pTitleLabel = dynamic_cast< CExLabel * >( FindChildByName( "TitleLabel" ) );
+	m_pRenderButton = dynamic_cast< CExButton * >( FindChildByName( "RenderButton" ) );
+	m_pCancelButton = dynamic_cast< CExButton * >( FindChildByName( "CancelButton" ) );
+	m_pBgPanel = dynamic_cast< EditablePanel * >( FindChildByName( "BGPanel" ) );
+	m_pMotionBlurCheck = dynamic_cast< CheckButton * >( FindChildByName( "MotionBlurEnabled" ) );
+	m_pQualityPresetLabel = dynamic_cast< CExLabel * >( FindChildByName( "QualityPresetLabel" ) );
+	m_pQualityPresetCombo = dynamic_cast< vgui::ComboBox * >( FindChildByName( "QualityPresetCombo" ) );
+	m_pCodecCombo = dynamic_cast< vgui::ComboBox * >( FindChildByName( "CodecCombo" ) );
+	m_pVideoModesCombo = dynamic_cast< vgui::ComboBox * >( FindChildByName( "VideoModeCombo" ) );
+	m_pEstimateTimeLabel = dynamic_cast< CExLabel * >( FindChildByName( "EstimateTimeLabel" ) );
+	m_pEstimateFileLabel = dynamic_cast< CExLabel * >( FindChildByName( "EstimateFileLabel" ) );
+	m_pSeparator = FindChildByName( "SeparatorLine" );
+	m_pGlowEnabledCheck = dynamic_cast< CheckButton * >( FindChildByName( "GlowEnabled" ) );
+	m_pLockWarningLabel = dynamic_cast< CExLabel * >( FindChildByName( "LockWarningLabel" ) );
+
+#if defined( TF_CLIENT_DLL )
+	if ( m_pBgPanel )
+	{
+		m_pBgPanel->SetPaintBackgroundType( 2 );	// Rounded.
+	}
+#endif
+
+	AddControlToAutoLayout( m_pTitleLabel, false );
+
+	// The replay may be REPLAY_HANDLE_INVALID in the case that we are about to render all unrendered replays
+	if ( m_hReplay != REPLAY_HANDLE_INVALID )
+	{
+		CGenericClassBasedReplay *pReplay = GetGenericClassBasedReplay( m_hReplay );
+		m_pTitleText->SetText( pReplay->m_wszTitle );
+		m_pTitleText->SetVisible( true );
+		m_pTitleLabel->SetText( "#Replay_RenderReplay" );
+		m_pEnterANameLabel->SetVisible( true );
+
+		AddControlToAutoLayout( m_pEnterANameLabel, false );
+	}
+	else
+	{
+		m_pTitleLabel->SetText( "#Replay_RenderReplays" );
+	}
+
+	m_pTitleText->SelectAllOnFocusAlways( true );
+
+	AddControlToAutoLayout( m_pTitleText, false );
+
+	// Update controls based on preset
+	SetValuesFromQualityPreset();
+
+	// Set quit button if necessary
+	if ( m_bSetQuit )
+	{
+		m_pQuitWhenDoneCheck->SetSelected( true );
+	}
+
+	m_pPlayVoiceCheck->SetProportional( false );
+	m_pQuitWhenDoneCheck->SetProportional( false );
+	m_pShowAdvancedOptionsCheck->SetProportional( false );
+	m_pMotionBlurCheck->SetProportional( false );
+	m_pMotionBlurSlider->InvalidateLayout( false, true );	// Without this, the range labels show up with "..." because of an invalid font in TextImage::ApplySchemeSettings().
+	m_pExportRawCheck->SetProportional( false );
+	m_pQualitySlider->InvalidateLayout( false, true );	// Without this, the range labels show up with "..." because of an invalid font in TextImage::ApplySchemeSettings().
+
+	if ( m_pGlowEnabledCheck )
+	{
+		m_pGlowEnabledCheck->SetProportional( false );
+	}
+
+	// Fill in combo box with preset quality levels
+	const int nQualityPresetCount = ReplayVideo_GetQualityPresetCount();
+	m_pQualityPresetCombo->SetNumberOfEditLines( nQualityPresetCount );
+	for ( i = 0; i < nQualityPresetCount; ++i )
+	{
+		const ReplayQualityPreset_t &CurQualityPreset = ReplayVideo_GetQualityPreset( i );
+		m_pQualityPresetCombo->AddItem( CurQualityPreset.m_pName, NULL );
+		m_pQualityPresetCombo->SetItemEnabled( i, true );
+	}
+	m_pQualityPresetCombo->ActivateItem( m_pQualityPresetCombo->GetItemIDFromRow( m_iQualityPreset ) );
+
+	// Fill in combo box with video modes
+	int nScreenW = ScreenWidth();
+	int nScreenH = ScreenHeight();
+	const int nVidModeCount = ReplayVideo_GetVideoModeCount();
+	m_pVideoModesCombo->SetNumberOfEditLines( nVidModeCount );
+	bool bAtLeastOneVideoModeAdded = false;
+	bool bEnable = false;
+	bool bSkipped = false;
+	
+	for ( i = 0; i < nVidModeCount; ++i )
+	{
+		// Only offer display modes less than the current window size
+		const ReplayVideoMode_t	&CurVideoMode = ReplayVideo_GetVideoMode( i );
+
+		int nMw = CurVideoMode.m_nWidth;
+		int nMh = CurVideoMode.m_nHeight;
+
+		// Only display modes that fit in the current window
+		bEnable =  ( nMw <= nScreenW && nMh <= nScreenH );
+		if (!bEnable)
+			bSkipped = true;
+		
+		m_pVideoModesCombo->AddItem( CurVideoMode.m_pName, NULL );
+		m_pVideoModesCombo->SetItemEnabled( i, bEnable );
+
+		if (bEnable)
+			bAtLeastOneVideoModeAdded = true;
+	}
+	if ( bAtLeastOneVideoModeAdded )
+	{
+		m_pVideoModesCombo->ActivateItem( m_pVideoModesCombo->GetItemIDFromRow( 0 ) );
+	}
+
+	// fill in the combo box with codecs
+	const int nNumCodecs = ReplayVideo_GetCodecCount();
+	m_pCodecCombo->SetNumberOfEditLines( nNumCodecs );
+	for ( i = 0; i < nNumCodecs; ++i )
+	{
+		const ReplayCodec_t &CurCodec = ReplayVideo_GetCodec( i );
+		m_pCodecCombo->AddItem( CurCodec.m_pName, NULL );
+		m_pCodecCombo->SetItemEnabled( i, true );
+	}
+	m_pCodecCombo->ActivateItem( m_pCodecCombo->GetItemIDFromRow( 0 ) );
+
+	// now layout
+
+	// simplified options
+	AddControlToAutoLayout( m_pVideoModeLabel, false );
+	AddControlToAutoLayout( m_pVideoModesCombo, false );
+	// Show the note about "not all resolutions are available?"
+	if ( bSkipped && m_pResolutionNoteLabel )
+	{
+		m_pResolutionNoteLabel->SetVisible( true );
+		AddControlToAutoLayout( m_pResolutionNoteLabel, false );
+	}
+	// other simplified options
+	AddControlToAutoLayout( m_pQualityPresetLabel, false );
+	AddControlToAutoLayout( m_pQualityPresetCombo, false );
+	AddControlToAutoLayout( m_pEstimateTimeLabel, false );
+	AddControlToAutoLayout( m_pEstimateFileLabel, false );
+	AddControlToAutoLayout( m_pPlayVoiceCheck, false );
+	AddControlToAutoLayout( m_pShowAdvancedOptionsCheck, false );
+	AddControlToAutoLayout( m_pQuitWhenDoneCheck, false );
+
+	AddControlToAutoLayout( m_pLockWarningLabel, false );
+
+	// now advanced options
+	AddControlToAutoLayout( m_pSeparator, true );
+
+	AddControlToAutoLayout( m_pCodecLabel, true );
+	AddControlToAutoLayout( m_pCodecCombo, true );
+
+	if ( replay_rendersetting_motionblur_can_toggle.GetBool() )
+	{
+		AddControlToAutoLayout( m_pMotionBlurCheck, true );
+	}
+	else
+	{
+		m_pMotionBlurCheck->SetVisible( false );
+	}
+	AddControlToAutoLayout( m_pMotionBlurLabel, true );
+	AddControlToAutoLayout( m_pMotionBlurSlider, true );
+
+	AddControlToAutoLayout( m_pQualityLabel, true );
+	AddControlToAutoLayout( m_pQualitySlider, true );
+
+	AddControlToAutoLayout( m_pExportRawCheck, true );
+
+	if ( m_pGlowEnabledCheck )
+	{
+		AddControlToAutoLayout( m_pGlowEnabledCheck, true );
+	}
+
+	// these buttons always show up
+	AddControlToAutoLayout( m_pRenderButton, false );
+	AddControlToAutoLayout( m_pCancelButton, false );
+}
+
+void CReplayRenderDialog::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	m_pResolutionNoteLabel->SizeToContents();	// Get the proper height
+
+	int nY = m_nStartY;
+	Panel *pPrevPanel = NULL;
+	int nLastCtrlHeight = 0;
+
+	FOR_EACH_LL( m_lstControls, i )
+	{
+		LayoutInfo_t *pLayoutInfo = m_lstControls[ i ];
+		Panel *pPanel = pLayoutInfo->pPanel;
+
+		// should an advanced option be shown?
+		if ( pLayoutInfo->bAdvanced )
+		{
+			if ( pPanel->IsVisible() != m_bShowAdvancedOptions )
+			{
+				pPanel->SetVisible( m_bShowAdvancedOptions );
+			}
+		}
+
+		if ( !pPanel->IsVisible() )
+			continue;
+
+		if ( pPrevPanel && pLayoutInfo->nOffsetY >= 0 )
+		{
+			nY += pPrevPanel->GetTall() + pLayoutInfo->nOffsetY + m_nVerticalBuffer;
+		}
+
+		pPanel->SetPos( pLayoutInfo->nOffsetX ? pLayoutInfo->nOffsetX : m_nDefaultX, nY );
+
+		pPrevPanel = pPanel;
+		nLastCtrlHeight = pPanel->GetTall();
+	}
+
+	m_pBgPanel->SetTall( nY + nLastCtrlHeight + 2 * m_nVerticalBuffer );
+}
+
+void CReplayRenderDialog::Close()
+{
+	SetVisible( false );
+	MarkForDeletion();
+	TFModalStack()->PopModal( this );
+}
+
+void CReplayRenderDialog::OnCommand( const char *pCommand )
+{
+	if ( FStrEq( pCommand, "cancel" ) )
+	{
+		Close();
+	}
+	else if ( FStrEq( pCommand, "render" ) )
+	{
+		Close();
+		Render();
+	}
+	else
+	{
+		engine->ClientCmd( const_cast<char *>( pCommand ) );
+	}
+
+	BaseClass::OnCommand( pCommand );
+}
+
+void CReplayRenderDialog::Render()
+{
+	// Only complain about QuickTime if we aren't exporting raw TGA's/WAV
+	if ( !m_pExportRawCheck->IsSelected() )
+	{
+#ifndef USE_WEBM_FOR_REPLAY
+		if ( !g_pVideo || !g_pVideo->IsVideoSystemAvailable( VideoSystem::QUICKTIME ) )
+		{
+			ShowMessageBox( "#Replay_QuicktimeTitle", "#Replay_NeedQuicktime", "#GameUI_OK" );
+			return;
+		}
+		
+		if ( g_pVideo->GetVideoSystemStatus( VideoSystem::QUICKTIME ) != VideoSystemStatus::OK )
+		{
+			if ( g_pVideo->GetVideoSystemStatus( VideoSystem::QUICKTIME ) == VideoSystemStatus::NOT_CURRENT_VERSION )
+			{
+				ShowMessageBox( "#Replay_QuicktimeTitle", "#Replay_NeedQuicktimeNewer", "#GameUI_OK" );
+				return;	
+			}
+		
+			ShowMessageBox( "#Replay_QuicktimeTitle", "#Replay_Err_QT_FailedToLoad", "#GameUI_OK" );
+			return;
+		}
+#endif
+	}
+	
+	// Update convars from settings
+	const int nMotionBlurQuality = clamp( m_pMotionBlurSlider->GetValue(), 0, MAX_MOTION_BLUR_QUALITY );
+	replay_rendersetting_quitwhendone.SetValue( (int)m_pQuitWhenDoneCheck->IsSelected() );
+	replay_rendersetting_exportraw.SetValue( (int)m_pExportRawCheck->IsSelected() );
+	replay_rendersetting_motionblurquality.SetValue( nMotionBlurQuality );
+	replay_rendersetting_motionblurenabled.SetValue( replay_rendersetting_motionblur_can_toggle.GetBool() ? (int)m_pMotionBlurCheck->IsSelected() : 1 );
+	replay_rendersetting_encodingquality.SetValue( clamp( m_pQualitySlider->GetValue() * ReplayVideo_GetQualityInterval(), 0, 100 ) );
+
+	if ( m_pGlowEnabledCheck )
+	{
+		replay_rendersetting_renderglow.SetValue( m_pGlowEnabledCheck->IsSelected() );
+	}
+
+	ConVarRef replay_voice_during_playback( "replay_voice_during_playback" );
+	if ( replay_voice_during_playback.IsValid() && m_pPlayVoiceCheck->IsEnabled() )
+	{
+		replay_voice_during_playback.SetValue( (int)m_pPlayVoiceCheck->IsSelected() );
+	}
+
+	// Setup parameters for render
+	RenderMovieParams_t params;
+	params.m_hReplay = m_hReplay;
+	params.m_iPerformance = m_iPerformance;	// Use performance passed in from details panel
+	params.m_bQuitWhenFinished = m_pQuitWhenDoneCheck->IsSelected();
+	params.m_bExportRaw = m_pExportRawCheck->IsSelected();
+	m_pTitleText->GetText( params.m_wszTitle, sizeof( params.m_wszTitle ) );
+#ifdef USE_WEBM_FOR_REPLAY
+	V_strcpy_safe( params.m_szExtension, ".webm" );	// Use .webm
+#else
+	V_strcpy_safe( params.m_szExtension, ".mov" );	// Use .mov for Quicktime
+#endif
+
+	const int iRes = m_pVideoModesCombo->GetActiveItem();
+	const ReplayVideoMode_t &VideoMode = ReplayVideo_GetVideoMode( iRes );
+
+	params.m_Settings.m_bMotionBlurEnabled = replay_rendersetting_motionblurenabled.GetBool();
+	params.m_Settings.m_bAAEnabled = replay_rendersetting_motionblurenabled.GetBool();
+	params.m_Settings.m_nMotionBlurQuality = nMotionBlurQuality;
+	params.m_Settings.m_nWidth = VideoMode.m_nWidth;
+	params.m_Settings.m_nHeight = VideoMode.m_nHeight;
+	params.m_Settings.m_FPS.SetFPS( VideoMode.m_nBaseFPS, VideoMode.m_bNTSCRate );
+	params.m_Settings.m_Codec = ReplayVideo_GetCodec( m_pCodecCombo->GetActiveItem() ).m_nCodecId;
+	params.m_Settings.m_nEncodingQuality = replay_rendersetting_encodingquality.GetInt();
+	params.m_Settings.m_bRaw = m_pExportRawCheck->IsSelected();
+
+	// Calculate the framerate for the engine - for each engine frame, we need the # of motion blur timesteps,
+	// x 2, since the shutter is open for nNumMotionBlurTimeSteps and closed for nNumMotionBlurTimeSteps,
+	// with the engine frame centered in the shutter open state (ie when we're half way through the motion blur
+	// timesteps).  Antialiasing does not factor in here because it doesn't require extra frames - the AA jitter
+	// is interwoven in with the motion sub-frames.
+	const int nNumMotionBlurTimeSteps = ( params.m_Settings.m_bMotionBlurEnabled ) ? CReplayRenderer::GetNumMotionBlurTimeSteps( params.m_Settings.m_nMotionBlurQuality ) : 1;
+	
+	if ( params.m_Settings.m_bMotionBlurEnabled )
+	{
+	 	params.m_flEngineFps = 2 * nNumMotionBlurTimeSteps * params.m_Settings.m_FPS.GetFPS();
+	}
+	else
+	{
+		Assert( nNumMotionBlurTimeSteps == 1 );
+		params.m_flEngineFps = params.m_Settings.m_FPS.GetFPS();
+	}
+
+	// Close the browser
+	extern void ReplayUI_CloseReplayBrowser();
+	ReplayUI_CloseReplayBrowser();
+
+	// Hide the console
+	engine->ExecuteClientCmd( "hideconsole" );
+
+	// Stats tracking.
+	GetReplayGameStatsHelper().SW_ReplayStats_WriteRenderDataStart( params, this );
+
+	// Render the movie
+	g_pReplayMovieManager->RenderMovie( params );
+}
+
+void CReplayRenderDialog::OnKeyCodeTyped( vgui::KeyCode code )
+{
+	if( code == KEY_ENTER )
+	{
+		OnCommand( "render" );
+	}
+	else if ( code == KEY_ESCAPE )
+	{
+		MarkForDeletion();
+	}
+	else
+	{
+		BaseClass::OnKeyCodeTyped( code );
+	}
+}
+
+void CReplayRenderDialog::OnThink()
+{
+	if ( m_pEstimateTimeLabel == NULL || m_pEstimateFileLabel == NULL )
+		return;
+
+	// The replay may be NULL if this dialog is created by 'save all' from the quit confirmation dialog.  In this
+	// case, we don't want to a replay-specific time estimate anyway, so we can just early out here.
+	CGenericClassBasedReplay *pReplay = ToGenericClassBasedReplay( g_pReplayManager->GetReplay( m_hReplay) );
+	if ( !pReplay )
+		return;
+
+	const int nMotionBlurQuality = clamp( m_pMotionBlurSlider->GetValue(), 0, MAX_MOTION_BLUR_QUALITY );
+	const int nCodecQuality = clamp( m_pQualitySlider->GetValue(), 0, ReplayVideo_GetQualityRange() );
+	VideoEncodeCodec::EVideoEncodeCodec_t eCodec = ReplayVideo_GetCodec( m_pCodecCombo->GetActiveItem() ).m_nCodecId;
+
+	// fFrameSize is the scale factor based on the size of the rendered frame.  
+	const int iRes = m_pVideoModesCombo->GetActiveItem();
+	const ReplayVideoMode_t &VideoMode = ReplayVideo_GetVideoMode( iRes );
+	float fFrameSize = (float)(VideoMode.m_nWidth * VideoMode.m_nHeight)/(float)(640*480);
+	
+
+	float flEstimatedFileSize = 0;
+	float flEstimatedRenderTime_Min = 0;
+
+	static float mjpegToMotionBlurMultiplierTable[] = { 2.0f, 3.0f, 5.5f, 12.0f };
+	static float h264ToMotionBlurMultiplierTable[] = { 2.8f, 4.2f, 6.4f, 13.0f };
+	static float webmToMotionBlurMultiplierTable[] = { 2.8f, 4.2f, 6.4f, 13.0f };
+
+	static float mjpegToQualityMultiplierTable[] = { 620.0f, 736.0f, 1284.0f, 2115.0f, 3028.0f };
+	static float h264ToQualityMultiplierTable[] = { 276.0f, 384.0f, 595.0f, 1026.0f, 1873.0f };
+	static float webmToQualityMultiplierTable[] = { 125.0f, 250.0f, 312.0f, 673.0f, 1048.0f };
+
+	switch ( eCodec )
+	{
+	case VideoEncodeCodec::WEBM_CODEC:
+		flEstimatedFileSize			= pReplay->m_flLength * webmToQualityMultiplierTable[nCodecQuality]*fFrameSize;
+		flEstimatedRenderTime_Min	= pReplay->m_flLength * webmToMotionBlurMultiplierTable[nMotionBlurQuality];
+		break;
+	case VideoEncodeCodec::H264_CODEC:
+		flEstimatedFileSize			= pReplay->m_flLength * h264ToQualityMultiplierTable[nCodecQuality];
+		flEstimatedRenderTime_Min	= pReplay->m_flLength * h264ToMotionBlurMultiplierTable[nMotionBlurQuality];
+		break;
+	case VideoEncodeCodec::MJPEG_A_CODEC:
+		flEstimatedFileSize			= pReplay->m_flLength * mjpegToQualityMultiplierTable[nCodecQuality];
+		flEstimatedRenderTime_Min	= pReplay->m_flLength * mjpegToMotionBlurMultiplierTable[nMotionBlurQuality];
+		break;
+	}
+
+	float flEstimatedRenderTime_Max = flEstimatedRenderTime_Min * 3.0f;
+
+	// @todo Tom Bui: if this goes into hours, we are in trouble...
+	wchar_t wzFileSize[64];
+	_snwprintf( wzFileSize, ARRAYSIZE( wzFileSize ), L"%d", (int)flEstimatedFileSize );
+	wchar_t wzTimeMin[64];
+	wchar_t wzTimeMax[64];
+	g_pVGuiLocalize->ConvertANSIToUnicode( CReplayTime::FormatTimeString( flEstimatedRenderTime_Min ), wzTimeMin, sizeof( wzTimeMin ) );
+	g_pVGuiLocalize->ConvertANSIToUnicode( CReplayTime::FormatTimeString( flEstimatedRenderTime_Max ), wzTimeMax, sizeof( wzTimeMax ) );
+
+	wchar_t wzText[256] = L"";
+
+	g_pVGuiLocalize->ConstructString_safe( wzText, g_pVGuiLocalize->Find( "#Replay_RenderEstimate_File" ), 1, 
+									  wzFileSize,
+									  wzTimeMin,
+									  wzTimeMax );
+	m_pEstimateFileLabel->SetText( wzText );
+
+	g_pVGuiLocalize->ConstructString_safe( wzText, g_pVGuiLocalize->Find( "#Replay_RenderEstimate_Time" ), 2, 
+									  wzTimeMin,
+									  wzTimeMax );
+	m_pEstimateTimeLabel->SetText( wzText );
+}
+
+void CReplayRenderDialog::OnTextChanged( KeyValues *data )
+{
+	Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
+	vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );
+
+	if ( pComboBox == m_pQualityPresetCombo )
+	{
+		m_iQualityPreset = m_pQualityPresetCombo->GetActiveItem();
+		SetValuesFromQualityPreset();
+	}
+}
+
+void CReplayRenderDialog::OnCheckButtonChecked( vgui::Panel *panel )
+{
+	if ( panel == m_pShowAdvancedOptionsCheck )
+	{
+		m_bShowAdvancedOptions = m_pShowAdvancedOptionsCheck->IsSelected();
+		InvalidateLayout( true, false );
+	}
+}
+
+void CReplayRenderDialog::OnSetFocus()
+{
+	m_pTitleText->RequestFocus();
+}
+
+void ReplayUI_ShowRenderDialog( Panel* pParent, ReplayHandle_t hReplay, bool bSetQuit, int iPerformance )
+{
+	CReplayRenderDialog *pRenderDialog = vgui::SETUP_PANEL( new CReplayRenderDialog( pParent, hReplay, bSetQuit, iPerformance ) );
+
+	pRenderDialog->SetVisible( true );
+	pRenderDialog->MakePopup();
+	pRenderDialog->MoveToFront();
+	pRenderDialog->SetKeyBoardInputEnabled( true );
+	pRenderDialog->SetMouseInputEnabled( true );
+	TFModalStack()->PushModal( pRenderDialog );
+}
+
+#endif