mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-29 09:33:00 +00:00
640 lines
24 KiB
C++
640 lines
24 KiB
C++
//========= 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( params.m_szExtension, ".webm" ); // Use .webm
|
|
#else
|
|
V_strcpy( 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( wzText, sizeof( wzText ), g_pVGuiLocalize->Find( "#Replay_RenderEstimate_File" ), 1,
|
|
wzFileSize,
|
|
wzTimeMin,
|
|
wzTimeMax );
|
|
m_pEstimateFileLabel->SetText( wzText );
|
|
|
|
g_pVGuiLocalize->ConstructString( wzText, sizeof( 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
|