Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1014 lines
33 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//=======================================================================================//
#include "cbase.h"
#if defined( REPLAY_ENABLED )
#include "replayrenderer.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/itexture.h"
#include "materialsystem/imaterialproxy.h"
#include "replay/vgui/replayrenderoverlay.h"
#include "replay/replay.h"
#include "replay/ireplaymoviemanager.h"
#include "replay/ireplayperformancecontroller.h"
#include "replay/ireplaymovie.h"
#include "replay/ireplaymanager.h"
#include "replay/ienginereplay.h"
#include "replay/iclientreplaycontext.h"
#include "view.h"
#include "iviewrender.h"
#include "view_shared.h"
#include "replay/replaycamera.h"
#include "bitmap/tgawriter.h"
#include "filesystem.h"
#define REPLAY_RECORDING_ENABLE
#ifdef REPLAY_RECORDING_ENABLE
#include "video/ivideoservices.h"
#endif
#define TMP_WAVE_FILENAME "tmpaudio"
//#define TRACE_REPLAY_STATE_MACHINE
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
//-----------------------------------------------------------------------------
extern IReplayMovieManager *g_pReplayMovieManager;
extern IReplayPerformanceController *g_pReplayPerformanceController;
// Map quality index to number of samples
static int s_DoFQualityToSamples[MAX_DOF_QUALITY+1] = {8, 16, 32};//, 64, 128 };
// 4-entry table of values in 2D -1 to +1 range using Poisson disk distribution
static Vector2D g_vJitterTable4[4] = { Vector2D (0.5318f, -0.6902f ), Vector2D (-0.5123f, 0.8362f ), Vector2D (-0.5193f, -0.2195f ), Vector2D (0.4749f, 0.3478f ) };
// 8-entry table of values in 2D -1 to +1 range using Poisson disk distribution
static Vector2D g_vJitterTable8[8] = { Vector2D (0.3475f, 0.0042f ),Vector2D (0.8806f, 0.3430f ),Vector2D (-0.0041f, -0.6197f ),Vector2D (0.0472f, 0.4964f ),
Vector2D (-0.3730f, 0.0874f ),Vector2D (-0.9217f, -0.3177f ),Vector2D (-0.6289f, 0.7388f ),Vector2D (0.5744f, -0.7741f ) };
// 16-entry table of values in 2D -1 to +1 range using Poisson disk distribution (disk size 0.38f)
static Vector2D g_vJitterTable16[16] = { Vector2D (0.0747f, -0.8341f ),Vector2D (-0.9138f, 0.3251f ),Vector2D (0.8667f, -0.3029f ),Vector2D (-0.4642f, 0.2187f ),
Vector2D (-0.1505f, 0.7320f ),Vector2D (0.7310f, -0.6786f ),Vector2D (0.2859f, -0.3254f ),Vector2D (-0.1311f, -0.2292f ),
Vector2D (0.3518f, 0.6470f ),Vector2D (-0.7485f, -0.6307f ),Vector2D (0.1687f, 0.1873f ),Vector2D (-0.3604f, -0.7483f ),
Vector2D (-0.5658f, -0.1521f ),Vector2D (0.7102f, 0.0536f ),Vector2D (-0.6056f, 0.7747f ),Vector2D (0.7793f, 0.6194f ) };
// 32-entry table of values in 2D -1 to +1 range using Poisson disk distribution (disk size 0.28f)
static Vector2D g_vJitterTable32[32] = { Vector2D (0.0854f, -0.0644f ),Vector2D (0.8744f, 0.1665f ),Vector2D (0.2329f, 0.3995f ),Vector2D (-0.7804f, 0.5482f ),
Vector2D (-0.4577f, 0.7647f ),Vector2D (-0.1936f, 0.5564f ),Vector2D (0.4205f, -0.5768f ),Vector2D (-0.0304f, -0.9050f ),
Vector2D (-0.5215f, 0.1854f ),Vector2D (0.3161f, -0.2954f ),Vector2D (0.0666f, -0.5564f ),Vector2D (-0.2137f, -0.0072f ),
Vector2D (-0.4112f, -0.3311f ),Vector2D (0.6438f, -0.2484f ),Vector2D (-0.9055f, -0.0360f ),Vector2D (0.8323f, 0.5268f ),
Vector2D (0.5592f, 0.3459f ),Vector2D (-0.6797f, -0.5201f ),Vector2D (-0.4325f, -0.8857f ),Vector2D (0.8768f, -0.4197f ),
Vector2D (0.3090f, -0.8646f ),Vector2D (0.5034f, 0.8603f ),Vector2D (0.3752f, 0.0627f ),Vector2D (-0.0161f, 0.2627f ),
Vector2D (0.0969f, 0.7054f ),Vector2D (-0.2291f, -0.6595f ),Vector2D (-0.5887f, -0.1100f ),Vector2D (0.7048f, -0.6528f ),
Vector2D (-0.8438f, 0.2706f ),Vector2D (-0.5061f, 0.4653f ),Vector2D (-0.1245f, -0.3302f ),Vector2D (-0.1801f, 0.8486f )};
//-----------------------------------------------------------------------------
//
// Accumulation material proxy for ping-pong accumulation buffer imp.
//
struct AccumParams_t
{
ITexture *m_pTexture0;
ITexture *m_pTexture1;
float m_fSampleWeight;
bool m_bClear;
};
class CAccumBuffProxy : public IMaterialProxy
{
public:
CAccumBuffProxy();
virtual ~CAccumBuffProxy();
virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
virtual void OnBind( void *pC_BaseEntity );
virtual void Release( void ) { delete this; }
virtual IMaterial *GetMaterial();
private:
IMaterialVar *m_pTexture0;
IMaterialVar *m_pTexture1;
IMaterialVar *m_pAccumBuffWeights;
};
//-----------------------------------------------------------------------------
CAccumBuffProxy::CAccumBuffProxy()
{
m_pTexture0 = NULL;
m_pTexture1 = NULL;
m_pAccumBuffWeights = NULL;
}
CAccumBuffProxy::~CAccumBuffProxy()
{
}
bool CAccumBuffProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
{
bool foundVar;
// Grab the Material variables for the accumulation shader
m_pTexture0 = pMaterial->FindVar( "$TEXTURE0", &foundVar, false );
if( !foundVar )
return false;
m_pTexture1 = pMaterial->FindVar( "$TEXTURE1", &foundVar, false );
if( !foundVar )
return false;
m_pAccumBuffWeights = pMaterial->FindVar( "$WEIGHTS", &foundVar, false );
if( !foundVar )
return false;
return true;
}
void CAccumBuffProxy::OnBind( void *pC_BaseEntity )
{
AccumParams_t *pAccumParams = (AccumParams_t *) pC_BaseEntity;
if( !m_pTexture0 || !m_pTexture1 || !m_pAccumBuffWeights )
{
return;
}
m_pTexture0->SetTextureValue( pAccumParams->m_pTexture0 );
m_pTexture1->SetTextureValue( pAccumParams->m_pTexture1 );
// If we're just using this material to do a clear to black...
if ( pAccumParams->m_bClear )
{
m_pAccumBuffWeights->SetVecValue( 0.0f, 0.0f, 0.0f, 0.0f );
}
else
{
m_pAccumBuffWeights->SetVecValue( pAccumParams->m_fSampleWeight, 1.0f - pAccumParams->m_fSampleWeight, 0.0f, 0.0f );
}
}
IMaterial *CAccumBuffProxy::GetMaterial()
{
return m_pAccumBuffWeights ? m_pAccumBuffWeights->GetOwningMaterial() : NULL;
}
//-----------------------------------------------------------------------------
EXPOSE_INTERFACE( CAccumBuffProxy, IMaterialProxy, "accumbuff4sample" IMATERIAL_PROXY_INTERFACE_VERSION );
//-----------------------------------------------------------------------------
CReplayRenderer::CReplayRenderer( CReplayRenderOverlay *pOverlay )
: m_bIsAudioSyncFrame( false ),
m_pRenderOverlay( pOverlay ),
m_nCurrentPingPong( 0 ),
m_nCurSample( 0 ),
m_nTimeStep( 0 ),
m_curSampleTime( 0 ),
m_nFrame( 0 ),
m_nNumJitterSamples( 0 ),
m_iTgaFrame( 0 ),
m_pLayoffBuf( NULL ),
m_pMovie( NULL ),
m_pMovieMaker( NULL ),
m_pJitterTable( NULL ),
m_pViewmodelFov( NULL ),
m_pDefaultFov( NULL ),
m_bCacheFullSceneState( false ),
m_bShutterClosed( false ),
m_bForceCheapDoF( false )
{
}
CReplayRenderer::~CReplayRenderer()
{
}
const CReplayPerformance *CReplayRenderer::GetPerformance() const
{
CReplay *pReplay = g_pReplayManager->GetPlayingReplay();
if ( !pReplay )
return NULL;
return m_RenderParams.m_iPerformance >= 0 ? pReplay->GetPerformance( m_RenderParams.m_iPerformance ) : NULL;
}
const char *CReplayRenderer::GetMovieFilename() const
{
if ( !m_pMovie )
return NULL;
return m_pMovie->GetMovieFilename();
}
// -------------------------------------------------------------------
// Functions used by audio engine to distinguish between sub-frames
// rendered for motion blur, and the actual frames being recorded
// -------------------------------------------------------------------
void CReplayRenderer::SetAudioSyncFrame( bool isSync )
{
m_bIsAudioSyncFrame = isSync;
}
bool CReplayRenderer::IsAudioSyncFrame()
{
return m_bIsAudioSyncFrame;
}
float CReplayRenderer::GetRecordingFrameDuration()
{
double actualFPS = m_RenderParams.m_Settings.m_FPS.GetFPS();
if ( actualFPS <= 0.0 )
{
Assert( false );
return 30.0f;
}
double interval = 1.0 / actualFPS;
return (float) interval;
}
bool CReplayRenderer::SetupRenderer( RenderMovieParams_t &params, IReplayMovie *pMovie )
{
// Cache render parameters
V_memcpy( &m_RenderParams, &params, sizeof( params ) );
// Cache movie
m_pMovie = pMovie;
// Reset current frame
m_nFrame = 0;
m_nTimeStep = 0;
m_nCurSample = 0;
m_iTgaFrame = 0;
m_curSampleTime = DmeTime_t(0);
m_pViewmodelFov = ( ConVar * )cvar->FindVar( "viewmodel_fov" );
m_pDefaultFov = ( ConVar * )cvar->FindVar( "default_fov" );
InitBuffers( params );
#ifdef REPLAY_RECORDING_ENABLE
// Record directly to a .wav file if desired via 'startmovie' and write out TGA's
if ( params.m_bExportRaw )
{
// Create the temporary wave file
g_pEngineClientReplay->Wave_CreateTmpFile( TMP_WAVE_FILENAME );
// Create the path for the movie
m_fmtTgaRenderDirName = g_pClientReplayContext->GetMovieManager()->GetRawExportDir();
g_pFullFileSystem->CreateDirHierarchy( m_fmtTgaRenderDirName.Access() );
}
else
{
// Record to a movie using video services.
if ( !g_pVideo )
return false;
#ifdef USE_WEBM_FOR_REPLAY
m_pMovieMaker = g_pVideo->CreateVideoRecorder( VideoSystem::WEBM );
#else
m_pMovieMaker = g_pVideo->CreateVideoRecorder( VideoSystem::QUICKTIME );
#endif
if ( !m_pMovieMaker )
return false;
CFmtStr fmtMovieFullFilename( "%s%s", g_pReplayMovieManager->GetRenderDir(), pMovie->GetMovieFilename() );
bool bSuccess = false;
if ( m_pMovieMaker->CreateNewMovieFile( fmtMovieFullFilename.Access(), true ) )
{
const ReplayRenderSettings_t &Settings = params.m_Settings;
#ifndef USE_WEBM_FOR_REPLAY
ConVarRef QTEncodeGamma( "video_quicktime_encode_gamma" );
VideoEncodeGamma_t encodeGamma = ( QTEncodeGamma.IsValid() ) ? (VideoEncodeGamma_t) QTEncodeGamma.GetInt() : VideoEncodeGamma::GAMMA_2_2;
#else
VideoEncodeGamma_t encodeGamma = VideoEncodeGamma::GAMMA_2_2;
#endif
if ( m_pMovieMaker->SetMovieVideoParameters( Settings.m_Codec, Settings.m_nEncodingQuality, (int)Settings.m_nWidth, (int)Settings.m_nHeight, Settings.m_FPS, encodeGamma ) )
{
if ( m_pMovieMaker->SetMovieSourceImageParameters( VideoEncodeSourceFormat::BGRA_32BIT, (int)Settings.m_nWidth, (int)Settings.m_nHeight ) )
{
AudioEncodeOptions_t audioOptions = AudioEncodeOptions::USE_AUDIO_ENCODE_GROUP_SIZE | AudioEncodeOptions::GROUP_SIZE_IS_VIDEO_FRAME |
AudioEncodeOptions::LIMIT_AUDIO_TRACK_TO_VIDEO_DURATION | AudioEncodeOptions::PAD_AUDIO_WITH_SILENCE ;
if ( m_pMovieMaker->SetMovieSourceAudioParameters( AudioEncodeSourceFormat::AUDIO_16BIT_PCMStereo, 44100, audioOptions ) )
{
bSuccess = true;
}
}
}
}
if ( !bSuccess )
{
g_pVideo->DestroyVideoRecorder( m_pMovieMaker );
m_pMovieMaker = NULL;
return false;
}
}
SetupJitterTable();
#endif
m_pRenderOverlay->Show();
return true;
}
bool CReplayRenderer::SetupJitterTable()
{
const int nNumSamples = NumMotionBlurTimeSteps();
switch ( nNumSamples )
{
case 4: m_pJitterTable = g_vJitterTable4; break;
case 8: m_pJitterTable = g_vJitterTable8; break;
case 16: m_pJitterTable = g_vJitterTable16; break;
case 32: m_pJitterTable = g_vJitterTable32; break;
// case 64: m_pJitterTable = g_vJitterTable64; break;
// case 128: m_pJitterTable = g_vJitterTable128; break;
default: return false;
}
m_nNumJitterSamples = nNumSamples;
return true;
}
void CReplayRenderer::InitBuffers( const RenderMovieParams_t &params )
{
const ReplayRenderSettings_t &Settings = params.m_Settings;
Assert( m_pLayoffBuf == NULL );
m_pLayoffBuf = new BGRA8888_t[ Settings.m_nWidth * Settings.m_nHeight ];
CFmtStr fmtHostFramerateCmd( "host_framerate %f\n", params.m_flEngineFps );
engine->ClientCmd_Unrestricted( fmtHostFramerateCmd.Access() );
g_pMaterialSystem->BeginRenderTargetAllocation(); // Begin allocating RTs which IFM can scribble into
// Offscreen surface for rendering individual samples
ImageFormat AccumSampleFormat = (g_pMaterialSystemHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT) ? IMAGE_FORMAT_RGBA16161616F : g_pMaterialSystem->GetBackBufferFormat();
m_AccumBuffSample.Init(
g_pMaterialSystem->CreateNamedRenderTargetTextureEx2(
"_rt_Replay_Accum_Sample", Settings.m_nWidth, Settings.m_nHeight, RT_SIZE_OFFSCREEN,
AccumSampleFormat, MATERIAL_RT_DEPTH_SHARED, TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE
)
);
// Ping-Pong textures for accumulating result prior to final tone map
ImageFormat PingPongFormat = IMAGE_FORMAT_BGR888;
m_AccumBuffPingPong[0].Init(g_pMaterialSystem->CreateNamedRenderTargetTextureEx2(
"_rt_Replay_Ping", Settings.m_nWidth, Settings.m_nHeight, RT_SIZE_OFFSCREEN,
PingPongFormat, MATERIAL_RT_DEPTH_NONE, TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE ));
m_AccumBuffPingPong[1].Init(g_pMaterialSystem->CreateNamedRenderTargetTextureEx2(
"_rt_Replay_Pong", Settings.m_nWidth, Settings.m_nHeight, RT_SIZE_OFFSCREEN,
PingPongFormat, MATERIAL_RT_DEPTH_NONE, TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_POINTSAMPLE ));
// LDR final result of either HDR or LDR rendering
m_LayoffResult.Init(g_pMaterialSystem->CreateNamedRenderTargetTextureEx2(
"_rt_LayoffResult", Settings.m_nWidth, Settings.m_nHeight, RT_SIZE_OFFSCREEN,
g_pMaterialSystem->GetBackBufferFormat(), MATERIAL_RT_DEPTH_SHARED, TEXTUREFLAGS_BORDER | TEXTUREFLAGS_POINTSAMPLE ));
g_pMaterialSystem->EndRenderTargetAllocation(); // Begin allocating RTs which IFM can scribble into
KeyValues *pVMTKeyValues = new KeyValues( "accumbuff4sample" );
pVMTKeyValues->SetString( "$TEXTURE0", m_AccumBuffSample->GetName() ); // Dummy
pVMTKeyValues->SetString( "$TEXTURE1", m_AccumBuffSample->GetName() ); // Dummy
pVMTKeyValues->SetString( "$TEXTURE2", m_AccumBuffSample->GetName() ); // Dummy
pVMTKeyValues->SetString( "$TEXTURE3", m_AccumBuffSample->GetName() ); // Dummy
pVMTKeyValues->SetString( "$WEIGHTS", "[0.25 0.75 0.0 0.0]" );
pVMTKeyValues->SetInt( "$nocull", 1 );
KeyValues *pProxiesKV = pVMTKeyValues->FindKey( "proxies", true ); // create a subkey
pProxiesKV->FindKey( "accumbuff4sample", true ); // create
m_FourSampleResolveMatRef.Init( "accumbuff4sample", pVMTKeyValues );
m_FourSampleResolveMatRef->Refresh();
}
void CReplayRenderer::ShutdownRenderer()
{
if ( m_LayoffResult.IsValid() )
{
m_LayoffResult.Shutdown( true );
}
if ( m_AccumBuffSample.IsValid() )
{
m_AccumBuffSample.Shutdown( true );
}
for ( int i = 0; i < 2; ++i )
{
if ( m_AccumBuffPingPong[i].IsValid() )
{
m_AccumBuffPingPong[i].Shutdown( true );
}
}
delete [] m_pLayoffBuf;
m_pLayoffBuf = NULL;
#ifdef REPLAY_RECORDING_ENABLE
if ( m_pMovieMaker )
{
m_pMovieMaker->FinishMovie( true );
if ( g_pVideo )
{
g_pVideo->DestroyVideoRecorder( m_pMovieMaker );
}
m_pMovieMaker = NULL;
m_pRenderOverlay->Hide();
}
else
#endif
if ( m_RenderParams.m_bExportRaw )
{
// Mimicking what "startmovie" does here.
g_pEngineClientReplay->Wave_FixupTmpFile( TMP_WAVE_FILENAME );
// Move the temp wave file to the destination dir
CFmtStr fmtTmpFilename( "%s%c%s.wav", engine->GetGameDirectory(), CORRECT_PATH_SEPARATOR, TMP_WAVE_FILENAME );
CFmtStr fmtDstFilename( "%s%s", m_fmtTgaRenderDirName.Access(), "audio.wav" );
g_pFullFileSystem->RenameFile( fmtTmpFilename.Access(), fmtDstFilename.Access() );
}
// Reset framerate
engine->ClientCmd_Unrestricted( "host_framerate 0" );
// Notify of performance end
g_pReplayPerformanceController->Stop();
}
void CReplayRenderer::DrawResolvingQuad( int nWidth, int nHeight )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
CMeshBuilder meshBuilder;
// Epsilons for 1:1 texel to pixel mapping
float fWidthEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nWidth);
float fHeightEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nHeight);
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( -1.0f, 1.0f, 0.5f ); // Upper left
meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 0.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( -1.0f, -1.0f, 0.5f ); // Lower left
meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 1.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 1.0f, -1.0f, 0.5f ); // Lower right
meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 1.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 1.0f, 1.0f, 0.5f ); // Upper right
meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 0.0f + fHeightEpsilon );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
void CReplayRenderer::BeginRenderingSample( int nSample, int x, int y, int nWidth, int nHeight, float fTonemapScale )
{
// Always start on ping-pong buffer zero
if ( nSample == 0 )
{
m_nCurrentPingPong = 0;
}
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->PushRenderTargetAndViewport( m_AccumBuffSample, x, y, nWidth, nHeight );
}
void CReplayRenderer::ResolveSamples( int nSample, DmeTime_t frametime, int x, int y, int nWidth, int nHeight, bool bLayoffResult, float flBloomScale )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
// Render resolving quad to current ping-pong buffer
AccumParams_t accParms = {
m_AccumBuffSample,
m_AccumBuffPingPong[ ( m_nCurrentPingPong + 1 ) % 2 ],
1.0f / (float)( nSample + 1 ),
false
};
pRenderContext->Bind( m_FourSampleResolveMatRef, &accParms );
pRenderContext->PushRenderTargetAndViewport( m_AccumBuffPingPong[m_nCurrentPingPong], x, y, nWidth, nHeight );
DrawResolvingQuad( nWidth, nHeight );
pRenderContext->PopRenderTargetAndViewport();
// If we want to show accumulated result to user...
if ( bLayoffResult )
{
accParms.m_pTexture0 = m_AccumBuffPingPong[m_nCurrentPingPong];
accParms.m_pTexture1 = m_AccumBuffPingPong[m_nCurrentPingPong];
accParms.m_fSampleWeight = 1.0f;
accParms.m_bClear = false;
pRenderContext->Bind( m_FourSampleResolveMatRef, &accParms );
pRenderContext->PushRenderTargetAndViewport( m_LayoffResult, x, y, nWidth, nHeight );
DrawResolvingQuad( nWidth, nHeight );
pRenderContext->PopRenderTargetAndViewport();
}
m_nCurrentPingPong = (m_nCurrentPingPong + 1) % 2; // Flip the ping-pong buffers
}
bool CReplayRenderer::IsHDR() const
{
return g_pMaterialSystemHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT;
}
float CReplayRenderer::GetViewModelFOVOffset()
{
// float flVMDefaultFov = m_pViewmodelFov ? m_pViewmodelFov->GetFloat() : 54.0f;
float flVMDefaultFov = 54.0f;
float flDefaultFov = m_pDefaultFov ? m_pDefaultFov->GetFloat() : 75.0f;
return flVMDefaultFov - flDefaultFov;
}
void CReplayRenderer::SetupSampleView( int x, int y, int w, int h, int nSample, CViewSetup& viewSetup )
{
// Frustum stuff
// FIXME: This currently matches the client DLL for HL2
// but we probably need a way of getting this state from the client DLL
viewSetup.zNear = 3;
viewSetup.zFar = 16384.0f * 1.73205080757f;
viewSetup.x = x;
viewSetup.y = y;
viewSetup.width = w;
viewSetup.height = h;
viewSetup.m_flAspectRatio = (float)viewSetup.width / (float)viewSetup.height;
const float fov = viewSetup.fov;
float fHalfAngleRadians = DEG2RAD( 0.5f * fov );
float t = tan( fHalfAngleRadians ) * (viewSetup.m_flAspectRatio / ( 4.0f / 3.0f ));
viewSetup.fov = RAD2DEG( 2.0f * atan( t ) );
viewSetup.fovViewmodel = viewSetup.fov + GetViewModelFOVOffset();
viewSetup.zNearViewmodel = 1;
viewSetup.zFarViewmodel = viewSetup.zFar;
viewSetup.m_bOrtho = false;
viewSetup.m_bRenderToSubrectOfLargerScreen = true;
SetupDOFMatrixSkewView( viewSetup.origin, viewSetup.angles, nSample, viewSetup ); // Sheared matrix method more comparable to image-space DoF approximation
// Only have the engine do bloom and tone mapping if not HDR
viewSetup.m_bDoBloomAndToneMapping = !IsHDR();
viewSetup.m_bCacheFullSceneState = m_bCacheFullSceneState;
}
void CReplayRenderer::SetupDOFMatrixSkewView( const Vector &pos, const QAngle &angles, int nSample, CViewSetup& viewSetup )
{
Vector vPosition = pos;
matrix3x4_t matViewMatrix; // Get transform
AngleMatrix( angles, matViewMatrix );
Vector vViewDirection, vViewLeft, vViewUp;
MatrixGetColumn( matViewMatrix, 0, vViewDirection );
MatrixGetColumn( matViewMatrix, 1, vViewLeft );
MatrixGetColumn( matViewMatrix, 2, vViewUp );
// Be sure these are normalized
vViewDirection.NormalizeInPlace();
vViewLeft.NormalizeInPlace();
vViewUp.NormalizeInPlace();
// Set up a non-skewed off-center projection matrix to start with... (Posters already have this set up)
viewSetup.m_bOffCenter = true;
viewSetup.m_flOffCenterBottom = 0.0f;
viewSetup.m_flOffCenterTop = 1.0f;
viewSetup.m_flOffCenterLeft = 0.0f;
viewSetup.m_flOffCenterRight = 1.0f;
if ( IsAntialiasingEnabled() && !IsDepthOfFieldEnabled() && !m_bForceCheapDoF ) // AA jitter but no DoF
{
Vector2D vAAJitter = m_pJitterTable[nSample % m_nNumJitterSamples];
const float fHalfPixelRadius = 0.65;
viewSetup.m_flOffCenterBottom += (vAAJitter.y / (float) viewSetup.height) * fHalfPixelRadius;
viewSetup.m_flOffCenterTop += (vAAJitter.y / (float) viewSetup.height) * fHalfPixelRadius;
viewSetup.m_flOffCenterLeft += (vAAJitter.x / (float) viewSetup.width) * fHalfPixelRadius;
viewSetup.m_flOffCenterRight += (vAAJitter.x / (float) viewSetup.width) * fHalfPixelRadius;
viewSetup.origin = vPosition;
}
#if 0
if ( IsDepthOfFieldEnabled() || m_bForceCheapDoF ) // DoF (independent of AA jitter)
{
// Try to match the amount of blurriness from legacy fulcrum method
const float flDoFHack = 0.0008f;
Vector2D vDoFJitter = DepthOfFieldJitter( nSample ) * pCamera->GetAperture() * flDoFHack;
float fov43 = pCamera->GetFOVx();
float fHalfAngleRadians43 = DEG2RAD( 0.5f * fov43 );
float t = tan( fHalfAngleRadians43 ) * (viewSetup.m_flAspectRatio / ( 4.0f / 3.0f ));
float flZFocalWidth = t * pCamera->GetFocalDistance() * 2.0f; // Width of Viewport at Focal plane
Vector2D vFocalZJitter = vDoFJitter * flZFocalWidth;
viewSetup.m_flOffCenterBottom += vDoFJitter.y;
viewSetup.m_flOffCenterTop += vDoFJitter.y;
viewSetup.m_flOffCenterLeft += vDoFJitter.x;
viewSetup.m_flOffCenterRight += vDoFJitter.x;
viewSetup.origin = vPosition + vViewLeft * vFocalZJitter.x - vViewUp * vFocalZJitter.y * (1.0f / viewSetup.m_flAspectRatio);
if ( !m_bForceCheapDoF )
{
Vector2D vAAJitter = g_vJitterTable32[nSample % 32]; // Jitter in addition to DoF offset
const float fHalfPixelRadius = 0.6f;
viewSetup.m_flOffCenterBottom += (vAAJitter.y / (float) viewSetup.height) * fHalfPixelRadius;
viewSetup.m_flOffCenterTop += (vAAJitter.y / (float) viewSetup.height) * fHalfPixelRadius;
viewSetup.m_flOffCenterLeft += (vAAJitter.x / (float) viewSetup.width) * fHalfPixelRadius;
viewSetup.m_flOffCenterRight += (vAAJitter.x / (float) viewSetup.width) * fHalfPixelRadius;
}
}
#endif
MatrixAngles( matViewMatrix, viewSetup.angles );
}
int CReplayRenderer::GetMotionBlurQuality() const
{
return m_RenderParams.m_Settings.m_nMotionBlurQuality;
}
int CReplayRenderer::GetDepthOfFieldQuality() const
{
if ( !IsDepthOfFieldEnabled() )
return 0;
return MAX_DOF_QUALITY;
}
/*static*/ int CReplayRenderer::GetNumMotionBlurTimeSteps( int nQuality )
{
Assert( nQuality >= 0 && nQuality <= MAX_MOTION_BLUR_QUALITY );
// Map {0, 1, 2, 3, 4} to {8, 16, 32, 64, 128 }
return (int) pow(2.0f, nQuality+2 );
}
int CReplayRenderer::NumMotionBlurTimeSteps() const
{
return ( IsMotionBlurEnabled() ) ? GetNumMotionBlurTimeSteps( GetMotionBlurQuality() ) : 1;
}
bool CReplayRenderer::IsMotionBlurEnabled() const
{
return m_RenderParams.m_Settings.m_bMotionBlurEnabled;
}
bool CReplayRenderer::IsDepthOfFieldEnabled() const
{
return false;
}
bool CReplayRenderer::IsAntialiasingEnabled() const
{
return m_RenderParams.m_Settings.m_bAAEnabled;
}
void CReplayRenderer::ComputeSampleCounts( int *pNSamplesPerTimeStep, int *pNTotalSamples ) const
{
*pNSamplesPerTimeStep = *pNTotalSamples = 1;
if ( IsMotionBlurEnabled() )
{
*pNTotalSamples *= NumMotionBlurTimeSteps();
}
if ( IsDepthOfFieldEnabled() )
{
*pNTotalSamples *= s_DoFQualityToSamples[GetDepthOfFieldQuality()];
*pNSamplesPerTimeStep *= s_DoFQualityToSamples[GetDepthOfFieldQuality()];
}
}
float CReplayRenderer::GetFramerate() const
{
return m_RenderParams.m_Settings.m_FPS.GetFPS();
}
double CReplayRenderer::GetShutterSpeed() const
{
return 0.5 / m_RenderParams.m_Settings.m_FPS.GetFPS();
}
#ifdef TRACE_REPLAY_STATE_MACHINE
static int nFramesSent = 0;
#endif
void CReplayRenderer::CompositeAndLayoffFrame( int nFrame )
{
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg("CompositeAndLayoffFrame( %3d ) TStep=%d ...... ", nFrame, m_nTimeStep );
#endif
const int nMotionBlurTimeSteps = NumMotionBlurTimeSteps();
bool bAppendToMovie = false;
// Determine if this is a frame we handle audio on
bool AudioTrigger = (m_nTimeStep == 0) && !m_bShutterClosed;
SetAudioSyncFrame( AudioTrigger );
// If we aren't doing motion blur, just render the frame and add it to the video
if ( !IsMotionBlurEnabled() )
{
m_curSampleTime = DmeTime_t( nFrame, GetFramerate() );
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg( "Rendering Frame at T=%.4f ", m_curSampleTime.GetSeconds() );
#endif
RenderLayoffFrame( m_curSampleTime, 0, 1 ); // Just get one frame
bAppendToMovie = true;
goto render_to_video;
}
// Shutter closed?
if ( m_bShutterClosed )
{
m_nTimeStep++;
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg("Shutter Closed... TStep now %d", m_nTimeStep );
#endif
// If nMotionBlurTimeSteps subframes have passed, open the shutter for the next frame.
if ( m_nTimeStep >= nMotionBlurTimeSteps )
{
Assert( m_nTimeStep == nMotionBlurTimeSteps );
m_nTimeStep = 0;
m_bShutterClosed = false;
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg( ", Shutter OPENED, TStep=0");
#endif
}
#ifdef TRACE_REPLAY_STATE_MACHINE
ConVarRef HF( "host_framerate" );
float frameRate = HF.GetFloat();
Msg( ", DONE, ENgine FPS = %f\n", frameRate );
#endif
return;
}
// scope to avoid compiler warnings
{
// Shutter is open, accumulate sub-frames
int nSamplesPerTimeStep = 1;
int nNumTotalSamples = 1;
ComputeSampleCounts( &nSamplesPerTimeStep, &nNumTotalSamples );
double frameTime = DmeTime_t( nFrame, GetFramerate() ).GetSeconds();
DmeTime_t timeStepSize( GetShutterSpeed() );
DmeTime_t remainderStepSize( DmeTime_t( 1, GetFramerate() ) - timeStepSize );
Assert( timeStepSize.GetSeconds() > 0.0 );
DmeTime_t curSampleTime( frameTime );
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg("FrameT=%.4lf ", frameTime );
#endif
timeStepSize /= nMotionBlurTimeSteps;
curSampleTime -= timeStepSize * ( nMotionBlurTimeSteps - 1 ) / 2.0f;
// Loop through all samples for the current timestep, jittering the camera if antialiasing is enabled.
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg(" Shutter's Open, Rendering %d Sub-Frames ", nSamplesPerTimeStep );
Msg( "Frame %i: Laying off sub frame at time step %i \n", nFrame, m_nTimeStep );
#endif
RenderLayoffFrame( m_curSampleTime, m_nCurSample++, nNumTotalSamples );
++m_nTimeStep;
m_curSampleTime += timeStepSize;
// Catch the very last motionblur timestep and append to movie
if ( m_nTimeStep == nMotionBlurTimeSteps )
{
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg( " TStep=Max, Append=TRUE ... ");
#endif
m_nTimeStep = 0;
m_nCurSample = 0;
m_curSampleTime = curSampleTime;
m_bShutterClosed = true; // Close or open the shutter for nMotionBlurTimeSteps subframes
bAppendToMovie = true; // Add a frame to the movie we've just closed the shutter
}
}
render_to_video:
// Append the frame to the movie?
if ( bAppendToMovie )
{
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg(" -- Appending Frame %d to Movie\n", nFramesSent ); nFramesSent++;
#endif
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->PushRenderTargetAndViewport( m_LayoffResult );
// Add this frame to the movie
LayoffFrame( nFrame );
pRenderContext->PopRenderTargetAndViewport();
}
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg("\n");
#endif
}
void CReplayRenderer::LayoffFrame( int nFrame )
{
VPROF_BUDGET( "CReplayRenderer::LayoffFrame", VPROF_BUDGETGROUP_REPLAY );
// FIXME: This is somewhat of a hack to get layoff working again
// We're rendering into the full preview size, but stretching down to the actual size
Rect_t srcRect;
srcRect.x = 0;
srcRect.y = 0;
srcRect.width = m_RenderParams.m_Settings.m_nWidth;
srcRect.height = m_RenderParams.m_Settings.m_nHeight;
Rect_t dstRect;
dstRect.x = 0;
dstRect.y = 0;
dstRect.width = m_RenderParams.m_Settings.m_nWidth;
dstRect.height = m_RenderParams.m_Settings.m_nHeight;
#ifdef TRACE_REPLAY_STATE_MACHINE
Msg( "laying off movie frame %i\n", nFrame );
#endif
CMatRenderContextPtr pRenderContext( materials );
// pRenderContext->ReadPixelsAndStretch( &srcRect, &dstRect, (unsigned char*)m_pLayoffBuf,
// IMAGE_FORMAT_BGRA8888, dstRect.width * ImageLoader::SizeInBytes( IMAGE_FORMAT_BGRA8888 ) );
pRenderContext->ReadPixels( 0, 0, (int) m_RenderParams.m_Settings.m_nWidth, (int) m_RenderParams.m_Settings.m_nHeight, (unsigned char*)m_pLayoffBuf, IMAGE_FORMAT_BGRA8888 );
static ConVarRef mat_queue_mode( "mat_queue_mode" );
// Encode the frame
#ifdef REPLAY_RECORDING_ENABLE
if ( m_RenderParams.m_bExportRaw )
{
CUtlBuffer bufOut;
if ( TGAWriter::WriteToBuffer( (unsigned char *)m_pLayoffBuf, bufOut, m_RenderParams.m_Settings.m_nWidth,
m_RenderParams.m_Settings.m_nHeight, IMAGE_FORMAT_BGRA8888, IMAGE_FORMAT_RGB888 ) )
{
// Format filename and write the TGA
CFmtStr fmtFilename(
"%sFrame_%04i.tga",
m_fmtTgaRenderDirName.Access(),
m_iTgaFrame++
);
if ( !g_pFullFileSystem->WriteFile( fmtFilename.Access(), NULL, bufOut ) )
{
Warning( "Couldn't write bitmap data snapshot to file %s.\n", fmtFilename.Access() );
}
}
}
else if ( m_pMovieMaker )
{
// can't run in any other mode
Assert( mat_queue_mode.GetInt() == 0 );
VPROF_BUDGET( "CReplayRenderer::LayoffFrame - AppendVideoFrame", VPROF_BUDGETGROUP_REPLAY );
m_pMovieMaker->AppendVideoFrame( m_pLayoffBuf );
}
#endif
}
void CReplayRenderer::GetViewSetup( CViewSetup &viewsetup )
{
extern ConVar v_viewmodel_fov;
viewsetup = *view->GetPlayerViewSetup();
// HACK: Override the view - this will keep the view from popping if the user toggles the render preview checkbox.
ReplayCamera()->CalcView( viewsetup.origin, viewsetup.angles, viewsetup.fov );
viewsetup .fovViewmodel = ScaleFOVByWidthRatio( v_viewmodel_fov.GetFloat(), viewsetup.m_flAspectRatio / ( 4.0f / 3.0f ) );
}
void CReplayRenderer::RenderLayoffFrame( DmeTime_t time, int nCurSample, int nNumTotalSamples )
{
CViewSetup viewSetup;
GetViewSetup( viewSetup );
int x=0, y=0, w=m_RenderParams.m_Settings.m_nWidth, h=m_RenderParams.m_Settings.m_nHeight;
// FIXME: Using the preview size here is something of a hack
// to get layoff working again. We're actually going to stretch down from the preview size to layoff size
// during frame capture
float fTonemapScale = 0.28f;
BeginRenderingSample( nCurSample, x, y, w, h, fTonemapScale);
// Initialize view setup for this sample
SetupSampleView( 0, 0, w, h, nCurSample, viewSetup );
const int flags = RENDERVIEW_DRAWVIEWMODEL;
// Tell the engine to tell the client to render the view (sans viewmodel)
view->RenderView( viewSetup, VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH, flags );
// Resolve the accumulation buffer samples for display this frame
float fBloomScale = 0.28f;
bool bRenderFinalFrame = nCurSample == ( nNumTotalSamples - 1 );
ResolveSamples( nCurSample, time, 0, 0, w, h, bRenderFinalFrame, fBloomScale );
// Pop the target
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->PopRenderTargetAndViewport();
}
void CReplayRenderer::EndRendering()
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->PopRenderTargetAndViewport();
}
void CReplayRenderer::ClearToBlack( CTextureReference &buf, int x, int y, int nWidth, int nHeight )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
// Bind the resolving material
AccumParams_t accParms = { m_AccumBuffSample, m_AccumBuffSample, 0.0f, true }; // true to clear to black
pRenderContext->Bind( m_FourSampleResolveMatRef, &accParms );
// Render black quad to the layoff result
pRenderContext->PushRenderTargetAndViewport( buf, x, y, nWidth, nHeight );
DrawResolvingQuad( nWidth, nHeight );
pRenderContext->PopRenderTargetAndViewport();
}
void CReplayRenderer::RenderVideo()
{
#if _DEBUG
static ConVarRef replay_fake_render( "replay_fake_render" );
if ( replay_fake_render.IsValid() && replay_fake_render.GetBool() )
return;
#endif
if ( !engine->IsInGame() )
return;
if ( !m_LayoffResult.IsValid() )
return;
CompositeAndLayoffFrame( m_nFrame++ );
}
void CReplayRenderer::RenderAudio( unsigned char *pBuffer, int nSize, int nNumSamples )
{
#ifdef REPLAY_RECORDING_ENABLE
if ( m_RenderParams.m_bExportRaw )
{
g_pEngineClientReplay->Wave_AppendTmpFile( TMP_WAVE_FILENAME, pBuffer, nNumSamples );
}
else if ( m_pMovieMaker )
{
m_pMovieMaker->AppendAudioSamples( pBuffer, (size_t)nSize );
}
#endif
}
//-----------------------------------------------------------------------------
#endif