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.
294 lines
9.6 KiB
294 lines
9.6 KiB
//===== Copyright � 2013-2013, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose: Class to help with rendering CMDLs & CMergedMDLs to textures.
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "render_to_rt_helper.h"
|
|
#include "istudiorender.h"
|
|
#include "tier2/renderutils.h"
|
|
#include "materialsystem/MaterialSystemUtil.h"
|
|
#include "renderparm.h"
|
|
|
|
// NOTE: This has to be the last file included!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
// uncomment these to write out VTFs of the inventory icons with no lighting to be used for the "default icon images"
|
|
//#define WRITE_OUT_VTF
|
|
//#define ICON_VTF_BASE_PATH "d:/temp"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton
|
|
//-----------------------------------------------------------------------------
|
|
static CRenderToRTHelper s_RenderToRTHelper;
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CRenderToRTHelper, IRenderToRTHelper, RENDER_TO_RT_HELPER_INTERFACE_VERSION, s_RenderToRTHelper );
|
|
|
|
CRenderToRTHelper::CRenderToRTHelper()
|
|
: m_pCurrentObjectToRender( NULL )
|
|
, m_pPixelsReadEvent( NULL )
|
|
, m_pRenderTarget( NULL )
|
|
{
|
|
}
|
|
|
|
CRenderToRTHelper::~CRenderToRTHelper()
|
|
{
|
|
}
|
|
|
|
bool ProcessRenderToRTHelper()
|
|
{
|
|
return ( g_pRenderToRTHelper != NULL ) ? g_pRenderToRTHelper->Process() : false;
|
|
}
|
|
|
|
bool CRenderToRTHelper::Init()
|
|
{
|
|
if ( !g_pMaterialSystem )
|
|
return false;
|
|
|
|
memset( &m_LightingState, 0, sizeof(MaterialLightingState_t) );
|
|
for ( int i = 0; i < 6; ++i )
|
|
{
|
|
#ifdef WRITE_OUT_ICON_VTFS
|
|
m_LightingState.m_vecAmbientCube[i].Init( 0.f, 0.f, 0.f );
|
|
#else
|
|
m_LightingState.m_vecAmbientCube[i].Init( 0.15f, 0.15f, 0.15f );
|
|
#endif
|
|
}
|
|
|
|
//the default light is a blueish rim
|
|
m_LightingState.m_pLocalLightDesc[0].InitDirectional( Vector( -1.0f, 0.3f, 1.0f ), Vector( 1.5f, 1.8f, 2.0f ) );
|
|
m_LightingState.m_nLocalLightCount = 1;
|
|
|
|
m_pRenderTarget = g_pMaterialSystem->FindTexture( "render_to_rt_helper", TEXTURE_GROUP_RENDER_TARGET );
|
|
Assert( m_pRenderTarget );
|
|
m_pRenderTarget->AddRef();
|
|
|
|
g_pMaterialSystem->AddEndFramePriorToNextContextFunc( ::ProcessRenderToRTHelper );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void CRenderToRTHelper::Shutdown( void )
|
|
{
|
|
g_pMaterialSystem->RemoveEndFramePriorToNextContextFunc( ::ProcessRenderToRTHelper );
|
|
|
|
if ( m_pRenderTarget )
|
|
{
|
|
m_pRenderTarget->Release();
|
|
m_pRenderTarget = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void CRenderToRTHelper::LookAt( Camera_t& camera, const Vector &vecCenter, float flRadius, QAngle cameraAngles, Vector cameraOffset )
|
|
{
|
|
// Compute the distance to the camera for the object based on its
|
|
// radius and fov.
|
|
|
|
// clamp to a reasonable range
|
|
flRadius = clamp(flRadius, 6.0f, 20.0f);
|
|
|
|
// since tan( fov/2 ) = f/d
|
|
// cos( fov/2 ) = r / r' where r = sphere radius, r' = perp distance from sphere center to max extent of camera
|
|
// d/f = r'/d' where d' is distance of camera to sphere
|
|
// d' = r' / tan( fov/2 ) * r' = r / ( cos (fov/2) * tan( fov/2 ) ) = r / sin( fov/2 )
|
|
float flFOVx = camera.m_flFOVX;
|
|
flFOVx *= M_PI / 360.0f;
|
|
Vector vecCameraOffset( cameraOffset );
|
|
vecCameraOffset.x -= ( flRadius / sin( flFOVx ) );
|
|
|
|
// now setup the camera's origin and angles
|
|
matrix3x4_t matCameraPivot;
|
|
matrix3x4_t offset;
|
|
matrix3x4_t worldToCamera;
|
|
AngleMatrix( cameraAngles, vecCenter, matCameraPivot );
|
|
SetIdentityMatrix( offset );
|
|
MatrixSetColumn( vecCameraOffset, 3, offset );
|
|
ConcatTransforms( matCameraPivot, offset, worldToCamera );
|
|
MatrixAngles( worldToCamera, camera.m_angles, camera.m_origin );
|
|
}
|
|
|
|
|
|
RenderToRTData_t *CRenderToRTHelper::CreateRenderToRTData( IRenderToRTHelperObject *pObject, IVTFTexture *pResultVTF )
|
|
{
|
|
RenderToRTData_t *pRenderToRTData = new RenderToRTData_t;
|
|
pRenderToRTData->m_pObject = pObject;
|
|
pRenderToRTData->m_pResultVTF = pResultVTF;
|
|
pRenderToRTData->m_LightingState = m_LightingState;
|
|
pRenderToRTData->m_cameraAngles = QAngle( 0.0f, -150.0f, 0.0f );
|
|
pRenderToRTData->m_cameraOffset = Vector( 0.0f, 1.0f, -1.0f );
|
|
pRenderToRTData->m_cameraFOV = 20.0f;
|
|
pRenderToRTData->m_bUsingExplicitModelCameraPosAnglesFromAttachment = false;
|
|
SetIdentityMatrix( pRenderToRTData->m_rootToWorld );
|
|
pRenderToRTData->m_stage = RENDER_TO_RT_STAGE_CREATED;
|
|
|
|
m_objectsToRender.AddToTail( pRenderToRTData );
|
|
|
|
return pRenderToRTData;
|
|
}
|
|
|
|
|
|
void CRenderToRTHelper::DestroyRenderToRTData( RenderToRTData_t *pRenderToRTData )
|
|
{
|
|
if ( pRenderToRTData->m_stage == RENDER_TO_RT_STAGE_WAITING_FOR_READ_BACK && m_pPixelsReadEvent )
|
|
{
|
|
m_pPixelsReadEvent->Wait();
|
|
delete m_pPixelsReadEvent;
|
|
m_pPixelsReadEvent = NULL;
|
|
}
|
|
|
|
if ( m_pCurrentObjectToRender == pRenderToRTData )
|
|
{
|
|
m_pCurrentObjectToRender = NULL;
|
|
}
|
|
|
|
pRenderToRTData->m_stage = RENDER_TO_RT_STAGE_UNDEFINED;
|
|
|
|
m_objectsToRender.FindAndRemove( pRenderToRTData );
|
|
delete pRenderToRTData;
|
|
}
|
|
|
|
void CRenderToRTHelper::StartRenderToRT( RenderToRTData_t *pRenderToRTData )
|
|
{
|
|
if ( pRenderToRTData->m_stage == RENDER_TO_RT_STAGE_CREATED )
|
|
{
|
|
// update camera here, because m_cameraAngles may have been changed
|
|
pRenderToRTData->m_Camera.Init( Vector( 0, 0, 0 ), QAngle( 0, 0, 0 ), 1.0f, 1000.0f, pRenderToRTData->m_cameraFOV, 1.0f );
|
|
|
|
if ( !pRenderToRTData->m_bUsingExplicitModelCameraPosAnglesFromAttachment )
|
|
{
|
|
float flRadius;
|
|
Vector vecCenter;
|
|
pRenderToRTData->m_pObject->GetBoundingSphere( vecCenter, flRadius );
|
|
LookAt( pRenderToRTData->m_Camera, vecCenter, flRadius, pRenderToRTData->m_cameraAngles, pRenderToRTData->m_cameraOffset );
|
|
}
|
|
else
|
|
{
|
|
pRenderToRTData->m_Camera.InitViewParameters( pRenderToRTData->m_cameraOffset, pRenderToRTData->m_cameraAngles );
|
|
}
|
|
|
|
#ifdef WRITE_OUT_ICON_VTFS
|
|
pRenderToRTData->m_LightingState.m_pLocalLightDesc[0].InitDirectional( Vector( 0.0f, 0.0f, 0.0f ), Vector( 0.0f, 0.0f, 0.0f ) );
|
|
pRenderToRTData->m_LightingState.m_nLocalLightCount = 1;
|
|
#endif
|
|
|
|
pRenderToRTData->m_stage = RENDER_TO_RT_STAGE_STARTED;
|
|
}
|
|
}
|
|
|
|
bool CRenderToRTHelper::Process()
|
|
{
|
|
bool bDidWork = false;
|
|
|
|
if ( !m_pCurrentObjectToRender && m_objectsToRender.Count() > 0 )
|
|
{
|
|
int nIndex = m_objectsToRender.Head();
|
|
while ( m_objectsToRender.IsValidIndex( nIndex ) )
|
|
{
|
|
if ( m_objectsToRender.Element( nIndex )->m_stage == RENDER_TO_RT_STAGE_STARTED )
|
|
{
|
|
m_pCurrentObjectToRender = m_objectsToRender.Element( nIndex );
|
|
break;
|
|
}
|
|
nIndex = m_objectsToRender.Next( nIndex );
|
|
}
|
|
}
|
|
|
|
if ( m_pCurrentObjectToRender )
|
|
{
|
|
if ( m_pCurrentObjectToRender->m_stage == RENDER_TO_RT_STAGE_STARTED && m_pRenderTarget != NULL && materials->CanDownloadTextures() )
|
|
{
|
|
// render it and save
|
|
|
|
m_pCurrentObjectToRender->m_pResultVTF->Init( m_pRenderTarget->GetActualWidth(), m_pRenderTarget->GetActualHeight(), m_pRenderTarget->GetActualDepth(), IMAGE_FORMAT_BGRA8888, 0, 1 );
|
|
|
|
int resolutionX = m_pRenderTarget->GetActualWidth();
|
|
int resolutionY = m_pRenderTarget->GetActualHeight();
|
|
unsigned char *pDestImage = m_pCurrentObjectToRender->m_pResultVTF->ImageData( 0, 0, 0 );
|
|
|
|
StudioRenderConfig_t oldStudioRenderConfig;
|
|
g_pStudioRender->GetCurrentConfig( oldStudioRenderConfig );
|
|
|
|
MaterialLock_t hLock = materials->Lock();
|
|
|
|
//init render context and set the the custom weapon RT as the current target
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
pRenderContext->PushRenderTargetAndViewport( m_pRenderTarget, 0, 0, resolutionX, resolutionY );
|
|
|
|
VMatrix view, projection;
|
|
ComputeViewMatrix( &view, m_pCurrentObjectToRender->m_Camera );
|
|
ComputeProjectionMatrix( &projection, m_pCurrentObjectToRender->m_Camera, resolutionX, resolutionY );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity( );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadMatrix( view );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadMatrix( projection );
|
|
|
|
pRenderContext->SetLightingState( m_pCurrentObjectToRender->m_LightingState );
|
|
|
|
pRenderContext->ClearColor4ub( 128, 128, 128, 0 );
|
|
//pRenderContext->ClearBuffersObeyStencilEx( true, true, true );
|
|
pRenderContext->ClearBuffers( true, true, true );
|
|
|
|
// We want the models to use their natural alpha, not depth in alpha
|
|
pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA, 0 );
|
|
|
|
// flashlights can't work in the model panel under queued mode (the state isn't ready yet, so causes a crash)
|
|
pRenderContext->SetFlashlightMode( false );
|
|
|
|
pRenderContext->BindLocalCubemap( m_pCurrentObjectToRender->m_pObject->GetEnvCubeMap() );
|
|
|
|
m_pCurrentObjectToRender->m_pObject->Draw( m_pCurrentObjectToRender->m_rootToWorld );
|
|
|
|
pRenderContext->ReadPixels( 0, 0, resolutionX, resolutionY, pDestImage, IMAGE_FORMAT_RGBA8888, m_pRenderTarget );
|
|
|
|
pRenderContext->PopRenderTargetAndViewport();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->Flush();
|
|
materials->Unlock( hLock );
|
|
|
|
g_pStudioRender->UpdateConfig( oldStudioRenderConfig );
|
|
|
|
m_pCurrentObjectToRender->m_stage = RENDER_TO_RT_STAGE_DONE;
|
|
|
|
bDidWork = true;
|
|
|
|
#ifdef WRITE_OUT_ICON_VTFS
|
|
static int s_nIconNumber = 0;
|
|
CUtlBuffer buf;
|
|
m_pCurrentObjectToRender->m_pResultVTF->Serialize(buf);
|
|
|
|
char szTextureName[MAX_PATH];
|
|
V_snprintf(szTextureName, MAX_PATH, "%s/inventory_icon_%s.vtf", ICON_VTF_BASE_PATH, m_pCurrentObjectToRender->m_pszIconNameSuffix );
|
|
|
|
FileHandle_t f = g_pFullFileSystem->Open(szTextureName, "wb", NULL);
|
|
|
|
if ( f != FILESYSTEM_INVALID_HANDLE )
|
|
{
|
|
g_pFullFileSystem->Write( buf.Base(), buf.TellMaxPut(), f );
|
|
g_pFullFileSystem->Close(f);
|
|
}
|
|
#endif
|
|
m_pCurrentObjectToRender = NULL;
|
|
}
|
|
}
|
|
|
|
return bDidWork;
|
|
}
|