//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Responsible for drawing the scene
//
//===========================================================================//
# include "cbase.h"
# include "view.h"
# include "iviewrender.h"
# include "view_shared.h"
# include "ivieweffects.h"
# include "iinput.h"
# include "model_types.h"
# include "clientsideeffects.h"
# include "particlemgr.h"
# include "viewrender.h"
# include "iclientmode.h"
# include "voice_status.h"
# include "glow_overlay.h"
# include "materialsystem/imesh.h"
# include "materialsystem/itexture.h"
# include "materialsystem/imaterial.h"
# include "materialsystem/imaterialvar.h"
# include "materialsystem/imaterialsystem.h"
# include "detailobjectsystem.h"
# include "tier0/vprof.h"
# include "tier1/mempool.h"
# include "vstdlib/jobthread.h"
# include "datacache/imdlcache.h"
# include "engine/IEngineTrace.h"
# include "engine/ivmodelinfo.h"
# include "tier0/icommandline.h"
# include "view_scene.h"
# include "particles_ez.h"
# include "engine/IStaticPropMgr.h"
# include "engine/ivdebugoverlay.h"
# include "c_pixel_visibility.h"
# include "clienteffectprecachesystem.h"
# include "c_rope.h"
# include "c_effects.h"
# include "smoke_fog_overlay.h"
# include "materialsystem/imaterialsystemhardwareconfig.h"
# include "VGuiMatSurface/IMatSystemSurface.h"
# include "vgui_int.h"
# include "ienginevgui.h"
# include "ScreenSpaceEffects.h"
# include "toolframework_client.h"
# include "c_func_reflective_glass.h"
# include "KeyValues.h"
# include "renderparm.h"
# include "studio_stats.h"
# include "con_nprint.h"
# include "clientmode_shared.h"
# include "sourcevr/isourcevirtualreality.h"
# include "client_virtualreality.h"
# ifdef PORTAL
//#include "C_Portal_Player.h"
# include "portal_render_targets.h"
# include "PortalRender.h"
# endif
# if defined( HL2_CLIENT_DLL ) || defined( CSTRIKE_DLL )
# define USE_MONITORS
# endif
# include "rendertexture.h"
# include "viewpostprocess.h"
# include "viewdebug.h"
# if defined USES_ECON_ITEMS
# include "econ_wearable.h"
# endif
# ifdef USE_MONITORS
# include "c_point_camera.h"
# endif // USE_MONITORS
// Projective textures
# include "C_Env_Projected_Texture.h"
// memdbgon must be the last include file in a .cpp file!!!
# include "tier0/memdbgon.h"
static void testfreezeframe_f ( void )
{
view - > FreezeFrame ( 3.0 ) ;
}
static ConCommand test_freezeframe ( " test_freezeframe " , testfreezeframe_f , " Test the freeze frame code. " , FCVAR_CHEAT ) ;
//-----------------------------------------------------------------------------
static ConVar r_visocclusion ( " r_visocclusion " , " 0 " , FCVAR_CHEAT ) ;
extern ConVar r_flashlightdepthtexture ;
extern ConVar vcollide_wireframe ;
extern ConVar mat_motion_blur_enabled ;
extern ConVar r_depthoverlay ;
extern ConVar mat_viewportscale ;
extern ConVar mat_viewportupscale ;
extern bool g_bDumpRenderTargets ;
//-----------------------------------------------------------------------------
// Convars related to controlling rendering
//-----------------------------------------------------------------------------
static ConVar cl_maxrenderable_dist ( " cl_maxrenderable_dist " , " 3000 " , FCVAR_CHEAT , " Max distance from the camera at which things will be rendered " ) ;
ConVar r_entityclips ( " r_entityclips " , " 1 " ) ; //FIXME: Nvidia drivers before 81.94 on cards that support user clip planes will have problems with this, require driver update? Detect and disable?
// Matches the version in the engine
static ConVar r_drawopaqueworld ( " r_drawopaqueworld " , " 1 " , FCVAR_CHEAT ) ;
static ConVar r_drawtranslucentworld ( " r_drawtranslucentworld " , " 1 " , FCVAR_CHEAT ) ;
static ConVar r_3dsky ( " r_3dsky " , " 1 " , 0 , " Enable the rendering of 3d sky boxes " ) ;
static ConVar r_skybox ( " r_skybox " , " 1 " , FCVAR_CHEAT , " Enable the rendering of sky boxes " ) ;
# ifdef TF_CLIENT_DLL
ConVar r_drawviewmodel ( " r_drawviewmodel " , " 1 " , FCVAR_ARCHIVE ) ;
# else
ConVar r_drawviewmodel ( " r_drawviewmodel " , " 1 " , FCVAR_CHEAT ) ;
# endif
static ConVar r_drawtranslucentrenderables ( " r_drawtranslucentrenderables " , " 1 " , FCVAR_CHEAT ) ;
static ConVar r_drawopaquerenderables ( " r_drawopaquerenderables " , " 1 " , FCVAR_CHEAT ) ;
static ConVar r_threaded_renderables ( " r_threaded_renderables " , " 0 " ) ;
// FIXME: This is not static because we needed to turn it off for TF2 playtests
ConVar r_DrawDetailProps ( " r_DrawDetailProps " , " 1 " , FCVAR_NONE , " 0=Off, 1=Normal, 2=Wireframe " ) ;
ConVar r_worldlistcache ( " r_worldlistcache " , " 1 " ) ;
//-----------------------------------------------------------------------------
// Convars related to fog color
//-----------------------------------------------------------------------------
static ConVar fog_override ( " fog_override " , " 0 " , FCVAR_CHEAT ) ;
// set any of these to use the maps fog
static ConVar fog_start ( " fog_start " , " -1 " , FCVAR_CHEAT ) ;
static ConVar fog_end ( " fog_end " , " -1 " , FCVAR_CHEAT ) ;
static ConVar fog_color ( " fog_color " , " -1 -1 -1 " , FCVAR_CHEAT ) ;
static ConVar fog_enable ( " fog_enable " , " 1 " , FCVAR_CHEAT ) ;
static ConVar fog_startskybox ( " fog_startskybox " , " -1 " , FCVAR_CHEAT ) ;
static ConVar fog_endskybox ( " fog_endskybox " , " -1 " , FCVAR_CHEAT ) ;
static ConVar fog_maxdensityskybox ( " fog_maxdensityskybox " , " -1 " , FCVAR_CHEAT ) ;
static ConVar fog_colorskybox ( " fog_colorskybox " , " -1 -1 -1 " , FCVAR_CHEAT ) ;
static ConVar fog_enableskybox ( " fog_enableskybox " , " 1 " , FCVAR_CHEAT ) ;
static ConVar fog_maxdensity ( " fog_maxdensity " , " -1 " , FCVAR_CHEAT ) ;
//-----------------------------------------------------------------------------
// Water-related convars
//-----------------------------------------------------------------------------
static ConVar r_debugcheapwater ( " r_debugcheapwater " , " 0 " , FCVAR_CHEAT ) ;
# ifndef _X360
static ConVar r_waterforceexpensive ( " r_waterforceexpensive " , " 0 " , FCVAR_ARCHIVE ) ;
# endif
static ConVar r_waterforcereflectentities ( " r_waterforcereflectentities " , " 0 " ) ;
static ConVar r_WaterDrawRefraction ( " r_WaterDrawRefraction " , " 1 " , 0 , " Enable water refraction " ) ;
static ConVar r_WaterDrawReflection ( " r_WaterDrawReflection " , " 1 " , 0 , " Enable water reflection " ) ;
static ConVar r_ForceWaterLeaf ( " r_ForceWaterLeaf " , " 1 " , 0 , " Enable for optimization to water - considers view in leaf under water for purposes of culling " ) ;
static ConVar mat_drawwater ( " mat_drawwater " , " 1 " , FCVAR_CHEAT ) ;
static ConVar mat_clipz ( " mat_clipz " , " 1 " ) ;
//-----------------------------------------------------------------------------
// Other convars
//-----------------------------------------------------------------------------
static ConVar r_screenfademinsize ( " r_screenfademinsize " , " 0 " ) ;
static ConVar r_screenfademaxsize ( " r_screenfademaxsize " , " 0 " ) ;
static ConVar cl_drawmonitors ( " cl_drawmonitors " , " 1 " ) ;
static ConVar r_eyewaterepsilon ( " r_eyewaterepsilon " , " 10.0f " , FCVAR_CHEAT ) ;
# ifdef TF_CLIENT_DLL
static ConVar pyro_dof ( " pyro_dof " , " 1 " , FCVAR_ARCHIVE ) ;
# endif
extern ConVar cl_leveloverview ;
extern ConVar localplayer_visionflags ;
//-----------------------------------------------------------------------------
// Globals
//-----------------------------------------------------------------------------
static Vector g_vecCurrentRenderOrigin ( 0 , 0 , 0 ) ;
static QAngle g_vecCurrentRenderAngles ( 0 , 0 , 0 ) ;
static Vector g_vecCurrentVForward ( 0 , 0 , 0 ) , g_vecCurrentVRight ( 0 , 0 , 0 ) , g_vecCurrentVUp ( 0 , 0 , 0 ) ;
static VMatrix g_matCurrentCamInverse ;
bool s_bCanAccessCurrentView = false ;
IntroData_t * g_pIntroData = NULL ;
static bool g_bRenderingView = false ; // For debugging...
static int g_CurrentViewID = VIEW_NONE ;
bool g_bRenderingScreenshot = false ;
# define FREEZECAM_SNAPSHOT_FADE_SPEED 340
float g_flFreezeFlash = 0.0f ;
//-----------------------------------------------------------------------------
CON_COMMAND ( r_cheapwaterstart , " " )
{
if ( args . ArgC ( ) = = 2 )
{
float dist = atof ( args [ 1 ] ) ;
view - > SetCheapWaterStartDistance ( dist ) ;
}
else
{
float start , end ;
view - > GetWaterLODParams ( start , end ) ;
Warning ( " r_cheapwaterstart: %f \n " , start ) ;
}
}
CON_COMMAND ( r_cheapwaterend , " " )
{
if ( args . ArgC ( ) = = 2 )
{
float dist = atof ( args [ 1 ] ) ;
view - > SetCheapWaterEndDistance ( dist ) ;
}
else
{
float start , end ;
view - > GetWaterLODParams ( start , end ) ;
Warning ( " r_cheapwaterend: %f \n " , end ) ;
}
}
//-----------------------------------------------------------------------------
// Describes a pruned set of leaves to be rendered this view. Reference counted
// because potentially shared by a number of views
//-----------------------------------------------------------------------------
struct ClientWorldListInfo_t : public CRefCounted1 < WorldListInfo_t >
{
ClientWorldListInfo_t ( )
{
memset ( ( WorldListInfo_t * ) this , 0 , sizeof ( WorldListInfo_t ) ) ;
m_pActualLeafIndex = NULL ;
m_bPooledAlloc = false ;
}
// Allocate a list intended for pruning
static ClientWorldListInfo_t * AllocPooled ( const ClientWorldListInfo_t & exemplar ) ;
// Because we remap leaves to eliminate unused leaves, we need a remap
// when drawing translucent surfaces, which requires the *original* leaf index
// using m_pActualLeafMap[ remapped leaf index ] == actual leaf index
LeafIndex_t * m_pActualLeafIndex ;
private :
virtual bool OnFinalRelease ( ) ;
bool m_bPooledAlloc ;
static CObjectPool < ClientWorldListInfo_t > gm_Pool ;
} ;
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
class CWorldListCache
{
public :
CWorldListCache ( )
{
}
void Flush ( )
{
for ( int i = m_Entries . FirstInorder ( ) ; i ! = m_Entries . InvalidIndex ( ) ; i = m_Entries . NextInorder ( i ) )
{
delete m_Entries [ i ] ;
}
m_Entries . RemoveAll ( ) ;
}
bool Find ( const CViewSetup & viewSetup , IWorldRenderList * * ppList , ClientWorldListInfo_t * * ppListInfo )
{
Entry_t lookup ( viewSetup ) ;
int i = m_Entries . Find ( & lookup ) ;
if ( i ! = m_Entries . InvalidIndex ( ) )
{
Entry_t * pEntry = m_Entries [ i ] ;
* ppList = InlineAddRef ( pEntry - > pList ) ;
* ppListInfo = InlineAddRef ( pEntry - > pListInfo ) ;
return true ;
}
return false ;
}
void Add ( const CViewSetup & viewSetup , IWorldRenderList * pList , ClientWorldListInfo_t * pListInfo )
{
m_Entries . Insert ( new Entry_t ( viewSetup , pList , pListInfo ) ) ;
}
private :
struct Entry_t
{
Entry_t ( const CViewSetup & viewSetup , IWorldRenderList * pList = NULL , ClientWorldListInfo_t * pListInfo = NULL ) :
pList ( ( pList ) ? InlineAddRef ( pList ) : NULL ) ,
pListInfo ( ( pListInfo ) ? InlineAddRef ( pListInfo ) : NULL )
{
// @NOTE (toml 8/18/2006): because doing memcmp, need to fill all of the fields and the padding!
memset ( & m_bOrtho , 0 , offsetof ( Entry_t , pList ) - offsetof ( Entry_t , m_bOrtho ) ) ;
m_bOrtho = viewSetup . m_bOrtho ;
m_OrthoLeft = viewSetup . m_OrthoLeft ;
m_OrthoTop = viewSetup . m_OrthoTop ;
m_OrthoRight = viewSetup . m_OrthoRight ;
m_OrthoBottom = viewSetup . m_OrthoBottom ;
fov = viewSetup . fov ;
origin = viewSetup . origin ;
angles = viewSetup . angles ;
zNear = viewSetup . zNear ;
zFar = viewSetup . zFar ;
m_flAspectRatio = viewSetup . m_flAspectRatio ;
m_bOffCenter = viewSetup . m_bOffCenter ;
m_flOffCenterTop = viewSetup . m_flOffCenterTop ;
m_flOffCenterBottom = viewSetup . m_flOffCenterBottom ;
m_flOffCenterLeft = viewSetup . m_flOffCenterLeft ;
m_flOffCenterRight = viewSetup . m_flOffCenterRight ;
}
~ Entry_t ( )
{
if ( pList )
pList - > Release ( ) ;
if ( pListInfo )
pListInfo - > Release ( ) ;
}
// The fields from CViewSetup that would actually affect the list
float m_OrthoLeft ;
float m_OrthoTop ;
float m_OrthoRight ;
float m_OrthoBottom ;
float fov ;
Vector origin ;
QAngle angles ;
float zNear ;
float zFar ;
float m_flAspectRatio ;
float m_flOffCenterTop ;
float m_flOffCenterBottom ;
float m_flOffCenterLeft ;
float m_flOffCenterRight ;
bool m_bOrtho ;
bool m_bOffCenter ;
IWorldRenderList * pList ;
ClientWorldListInfo_t * pListInfo ;
} ;
class CEntryComparator
{
public :
CEntryComparator ( int ) { }
bool operator ! ( ) const { return false ; }
bool operator ( ) ( const Entry_t * lhs , const Entry_t * rhs ) const
{
return ( memcmp ( lhs , rhs , sizeof ( Entry_t ) - ( sizeof ( Entry_t ) - offsetof ( Entry_t , pList ) ) ) < 0 ) ;
}
} ;
CUtlRBTree < Entry_t * , unsigned short , CEntryComparator > m_Entries ;
} ;
CWorldListCache g_WorldListCache ;
//-----------------------------------------------------------------------------
// Standard 3d skybox view
//-----------------------------------------------------------------------------
class CSkyboxView : public CRendering3dView
{
DECLARE_CLASS ( CSkyboxView , CRendering3dView ) ;
public :
CSkyboxView ( CViewRender * pMainView ) :
CRendering3dView ( pMainView ) ,
m_pSky3dParams ( NULL )
{
}
bool Setup ( const CViewSetup & view , int * pClearFlags , SkyboxVisibility_t * pSkyboxVisible ) ;
void Draw ( ) ;
protected :
# ifdef PORTAL
virtual bool ShouldDrawPortals ( ) { return false ; }
# endif
virtual SkyboxVisibility_t ComputeSkyboxVisibility ( ) ;
bool GetSkyboxFogEnable ( ) ;
void Enable3dSkyboxFog ( void ) ;
void DrawInternal ( view_id_t iSkyBoxViewID , bool bInvokePreAndPostRender , ITexture * pRenderTarget , ITexture * pDepthTarget ) ;
sky3dparams_t * PreRender3dSkyboxWorld ( SkyboxVisibility_t nSkyboxVisible ) ;
sky3dparams_t * m_pSky3dParams ;
} ;
//-----------------------------------------------------------------------------
// 3d skybox view when drawing portals
//-----------------------------------------------------------------------------
# ifdef PORTAL
class CPortalSkyboxView : public CSkyboxView
{
DECLARE_CLASS ( CPortalSkyboxView , CSkyboxView ) ;
public :
CPortalSkyboxView ( CViewRender * pMainView ) :
CSkyboxView ( pMainView ) ,
m_pRenderTarget ( NULL )
{ }
bool Setup ( const CViewSetup & view , int * pClearFlags , SkyboxVisibility_t * pSkyboxVisible , ITexture * pRenderTarget = NULL ) ;
//Skybox drawing through portals with workarounds to fix area bits, position/scaling, view id's..........
void Draw ( ) ;
private :
virtual SkyboxVisibility_t ComputeSkyboxVisibility ( ) ;
ITexture * m_pRenderTarget ;
} ;
# endif
//-----------------------------------------------------------------------------
// Shadow depth texture
//-----------------------------------------------------------------------------
class CShadowDepthView : public CRendering3dView
{
DECLARE_CLASS ( CShadowDepthView , CRendering3dView ) ;
public :
CShadowDepthView ( CViewRender * pMainView ) : CRendering3dView ( pMainView ) { }
void Setup ( const CViewSetup & shadowViewIn , ITexture * pRenderTarget , ITexture * pDepthTexture ) ;
void Draw ( ) ;
private :
ITexture * m_pRenderTarget ;
ITexture * m_pDepthTexture ;
} ;
//-----------------------------------------------------------------------------
// Freeze frame. Redraws the frame at which it was enabled.
//-----------------------------------------------------------------------------
class CFreezeFrameView : public CRendering3dView
{
DECLARE_CLASS ( CFreezeFrameView , CRendering3dView ) ;
public :
CFreezeFrameView ( CViewRender * pMainView ) : CRendering3dView ( pMainView ) { }
void Setup ( const CViewSetup & view ) ;
void Draw ( ) ;
private :
CMaterialReference m_pFreezeFrame ;
CMaterialReference m_TranslucentSingleColor ;
} ;
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
class CBaseWorldView : public CRendering3dView
{
DECLARE_CLASS ( CBaseWorldView , CRendering3dView ) ;
protected :
CBaseWorldView ( CViewRender * pMainView ) : CRendering3dView ( pMainView ) { }
virtual bool AdjustView ( float waterHeight ) ;
void DrawSetup ( float waterHeight , int flags , float waterZAdjust , int iForceViewLeaf = - 1 ) ;
void DrawExecute ( float waterHeight , view_id_t viewID , float waterZAdjust ) ;
virtual void PushView ( float waterHeight ) ;
virtual void PopView ( ) ;
void SSAO_DepthPass ( ) ;
void DrawDepthOfField ( ) ;
} ;
//-----------------------------------------------------------------------------
// Draws the scene when there's no water or only cheap water
//-----------------------------------------------------------------------------
class CSimpleWorldView : public CBaseWorldView
{
DECLARE_CLASS ( CSimpleWorldView , CBaseWorldView ) ;
public :
CSimpleWorldView ( CViewRender * pMainView ) : CBaseWorldView ( pMainView ) { }
void Setup ( const CViewSetup & view , int nClearFlags , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & info , ViewCustomVisibility_t * pCustomVisibility = NULL ) ;
void Draw ( ) ;
private :
VisibleFogVolumeInfo_t m_fogInfo ;
} ;
//-----------------------------------------------------------------------------
// Base class for scenes with water
//-----------------------------------------------------------------------------
class CBaseWaterView : public CBaseWorldView
{
DECLARE_CLASS ( CBaseWaterView , CBaseWorldView ) ;
public :
CBaseWaterView ( CViewRender * pMainView ) :
CBaseWorldView ( pMainView ) ,
m_SoftwareIntersectionView ( pMainView )
{ }
// void Setup( const CViewSetup &, const WaterRenderInfo_t& info );
protected :
void CalcWaterEyeAdjustments ( const VisibleFogVolumeInfo_t & fogInfo , float & newWaterHeight , float & waterZAdjust , bool bSoftwareUserClipPlane ) ;
class CSoftwareIntersectionView : public CBaseWorldView
{
DECLARE_CLASS ( CSoftwareIntersectionView , CBaseWorldView ) ;
public :
CSoftwareIntersectionView ( CViewRender * pMainView ) : CBaseWorldView ( pMainView ) { }
void Setup ( bool bAboveWater ) ;
void Draw ( ) ;
private :
CBaseWaterView * GetOuter ( ) { return GET_OUTER ( CBaseWaterView , m_SoftwareIntersectionView ) ; }
} ;
friend class CSoftwareIntersectionView ;
CSoftwareIntersectionView m_SoftwareIntersectionView ;
WaterRenderInfo_t m_waterInfo ;
float m_waterHeight ;
float m_waterZAdjust ;
bool m_bSoftwareUserClipPlane ;
VisibleFogVolumeInfo_t m_fogInfo ;
} ;
//-----------------------------------------------------------------------------
// Scenes above water
//-----------------------------------------------------------------------------
class CAboveWaterView : public CBaseWaterView
{
DECLARE_CLASS ( CAboveWaterView , CBaseWaterView ) ;
public :
CAboveWaterView ( CViewRender * pMainView ) :
CBaseWaterView ( pMainView ) ,
m_ReflectionView ( pMainView ) ,
m_RefractionView ( pMainView ) ,
m_IntersectionView ( pMainView )
{ }
void Setup ( const CViewSetup & view , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo ) ;
void Draw ( ) ;
class CReflectionView : public CBaseWorldView
{
DECLARE_CLASS ( CReflectionView , CBaseWorldView ) ;
public :
CReflectionView ( CViewRender * pMainView ) : CBaseWorldView ( pMainView ) { }
void Setup ( bool bReflectEntities ) ;
void Draw ( ) ;
private :
CAboveWaterView * GetOuter ( ) { return GET_OUTER ( CAboveWaterView , m_ReflectionView ) ; }
} ;
class CRefractionView : public CBaseWorldView
{
DECLARE_CLASS ( CRefractionView , CBaseWorldView ) ;
public :
CRefractionView ( CViewRender * pMainView ) : CBaseWorldView ( pMainView ) { }
void Setup ( ) ;
void Draw ( ) ;
private :
CAboveWaterView * GetOuter ( ) { return GET_OUTER ( CAboveWaterView , m_RefractionView ) ; }
} ;
class CIntersectionView : public CBaseWorldView
{
DECLARE_CLASS ( CIntersectionView , CBaseWorldView ) ;
public :
CIntersectionView ( CViewRender * pMainView ) : CBaseWorldView ( pMainView ) { }
void Setup ( ) ;
void Draw ( ) ;
private :
CAboveWaterView * GetOuter ( ) { return GET_OUTER ( CAboveWaterView , m_IntersectionView ) ; }
} ;
friend class CRefractionView ;
friend class CReflectionView ;
friend class CIntersectionView ;
bool m_bViewIntersectsWater ;
CReflectionView m_ReflectionView ;
CRefractionView m_RefractionView ;
CIntersectionView m_IntersectionView ;
} ;
//-----------------------------------------------------------------------------
// Scenes below water
//-----------------------------------------------------------------------------
class CUnderWaterView : public CBaseWaterView
{
DECLARE_CLASS ( CUnderWaterView , CBaseWaterView ) ;
public :
CUnderWaterView ( CViewRender * pMainView ) :
CBaseWaterView ( pMainView ) ,
m_RefractionView ( pMainView )
{ }
void Setup ( const CViewSetup & view , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & info ) ;
void Draw ( ) ;
class CRefractionView : public CBaseWorldView
{
DECLARE_CLASS ( CRefractionView , CBaseWorldView ) ;
public :
CRefractionView ( CViewRender * pMainView ) : CBaseWorldView ( pMainView ) { }
void Setup ( ) ;
void Draw ( ) ;
private :
CUnderWaterView * GetOuter ( ) { return GET_OUTER ( CUnderWaterView , m_RefractionView ) ; }
} ;
friend class CRefractionView ;
bool m_bDrawSkybox ; // @MULTICORE (toml 8/17/2006): remove after setup hoisted
CRefractionView m_RefractionView ;
} ;
//-----------------------------------------------------------------------------
// Scenes containing reflective glass
//-----------------------------------------------------------------------------
class CReflectiveGlassView : public CSimpleWorldView
{
DECLARE_CLASS ( CReflectiveGlassView , CSimpleWorldView ) ;
public :
CReflectiveGlassView ( CViewRender * pMainView ) : BaseClass ( pMainView )
{
}
virtual bool AdjustView ( float flWaterHeight ) ;
virtual void PushView ( float waterHeight ) ;
virtual void PopView ( ) ;
void Setup ( const CViewSetup & view , int nClearFlags , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo , const cplane_t & reflectionPlane ) ;
void Draw ( ) ;
cplane_t m_ReflectionPlane ;
} ;
class CRefractiveGlassView : public CSimpleWorldView
{
DECLARE_CLASS ( CRefractiveGlassView , CSimpleWorldView ) ;
public :
CRefractiveGlassView ( CViewRender * pMainView ) : BaseClass ( pMainView )
{
}
virtual bool AdjustView ( float flWaterHeight ) ;
virtual void PushView ( float waterHeight ) ;
virtual void PopView ( ) ;
void Setup ( const CViewSetup & view , int nClearFlags , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo , const cplane_t & reflectionPlane ) ;
void Draw ( ) ;
cplane_t m_ReflectionPlane ;
} ;
//-----------------------------------------------------------------------------
// Computes draw flags for the engine to build its world surface lists
//-----------------------------------------------------------------------------
static inline unsigned long BuildEngineDrawWorldListFlags ( unsigned nDrawFlags )
{
unsigned long nEngineFlags = 0 ;
if ( nDrawFlags & DF_DRAWSKYBOX )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_SKYBOX ;
}
if ( nDrawFlags & DF_RENDER_ABOVEWATER )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_STRICTLYABOVEWATER ;
nEngineFlags | = DRAWWORLDLISTS_DRAW_INTERSECTSWATER ;
}
if ( nDrawFlags & DF_RENDER_UNDERWATER )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_STRICTLYUNDERWATER ;
nEngineFlags | = DRAWWORLDLISTS_DRAW_INTERSECTSWATER ;
}
if ( nDrawFlags & DF_RENDER_WATER )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_WATERSURFACE ;
}
if ( nDrawFlags & DF_CLIP_SKYBOX )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_CLIPSKYBOX ;
}
if ( nDrawFlags & DF_SHADOW_DEPTH_MAP )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_SHADOWDEPTH ;
}
if ( nDrawFlags & DF_RENDER_REFRACTION )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_REFRACTION ;
}
if ( nDrawFlags & DF_RENDER_REFLECTION )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_REFLECTION ;
}
if ( nDrawFlags & DF_SSAO_DEPTH_PASS )
{
nEngineFlags | = DRAWWORLDLISTS_DRAW_SSAO | DRAWWORLDLISTS_DRAW_STRICTLYUNDERWATER | DRAWWORLDLISTS_DRAW_INTERSECTSWATER | DRAWWORLDLISTS_DRAW_STRICTLYABOVEWATER ;
nEngineFlags & = ~ ( DRAWWORLDLISTS_DRAW_WATERSURFACE | DRAWWORLDLISTS_DRAW_REFRACTION | DRAWWORLDLISTS_DRAW_REFLECTION ) ;
}
return nEngineFlags ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void SetClearColorToFogColor ( )
{
unsigned char ucFogColor [ 3 ] ;
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > GetFogColor ( ucFogColor ) ;
if ( g_pMaterialSystemHardwareConfig - > GetHDRType ( ) = = HDR_TYPE_INTEGER )
{
// @MULTICORE (toml 8/16/2006): Find a way to not do this twice in eye above water case
float scale = LinearToGammaFullRange ( pRenderContext - > GetToneMappingScaleLinear ( ) . x ) ;
ucFogColor [ 0 ] * = scale ;
ucFogColor [ 1 ] * = scale ;
ucFogColor [ 2 ] * = scale ;
}
pRenderContext - > ClearColor4ub ( ucFogColor [ 0 ] , ucFogColor [ 1 ] , ucFogColor [ 2 ] , 255 ) ;
}
//-----------------------------------------------------------------------------
// Precache of necessary materials
//-----------------------------------------------------------------------------
# ifdef HL2_CLIENT_DLL
CLIENTEFFECT_REGISTER_BEGIN ( PrecacheViewRender )
CLIENTEFFECT_MATERIAL ( " scripted/intro_screenspaceeffect " )
CLIENTEFFECT_REGISTER_END ( )
# endif
CLIENTEFFECT_REGISTER_BEGIN ( PrecachePostProcessingEffects )
CLIENTEFFECT_MATERIAL ( " dev/blurfiltery_and_add_nohdr " )
CLIENTEFFECT_MATERIAL ( " dev/blurfilterx " )
CLIENTEFFECT_MATERIAL ( " dev/blurfilterx_nohdr " )
CLIENTEFFECT_MATERIAL ( " dev/blurfiltery " )
CLIENTEFFECT_MATERIAL ( " dev/blurfiltery_nohdr " )
CLIENTEFFECT_MATERIAL ( " dev/bloomadd " )
CLIENTEFFECT_MATERIAL ( " dev/downsample " )
# ifdef CSTRIKE_DLL
CLIENTEFFECT_MATERIAL ( " dev/downsample_non_hdr_cstrike " )
# else
CLIENTEFFECT_MATERIAL ( " dev/downsample_non_hdr " )
# endif
CLIENTEFFECT_MATERIAL ( " dev/no_pixel_write " )
CLIENTEFFECT_MATERIAL ( " dev/lumcompare " )
CLIENTEFFECT_MATERIAL ( " dev/floattoscreen_combine " )
CLIENTEFFECT_MATERIAL ( " dev/copyfullframefb_vanilla " )
CLIENTEFFECT_MATERIAL ( " dev/copyfullframefb " )
CLIENTEFFECT_MATERIAL ( " dev/engine_post " )
CLIENTEFFECT_MATERIAL ( " dev/motion_blur " )
CLIENTEFFECT_MATERIAL ( " dev/upscale " )
# ifdef TF_CLIENT_DLL
CLIENTEFFECT_MATERIAL ( " dev/pyro_blur_filter_y " )
CLIENTEFFECT_MATERIAL ( " dev/pyro_blur_filter_x " )
CLIENTEFFECT_MATERIAL ( " dev/pyro_dof " )
CLIENTEFFECT_MATERIAL ( " dev/pyro_vignette_border " )
CLIENTEFFECT_MATERIAL ( " dev/pyro_vignette " )
CLIENTEFFECT_MATERIAL ( " dev/pyro_post " )
# endif
CLIENTEFFECT_REGISTER_END_CONDITIONAL ( engine - > GetDXSupportLevel ( ) > = 90 )
//-----------------------------------------------------------------------------
// Accessors to return the current view being rendered
//-----------------------------------------------------------------------------
const Vector & CurrentViewOrigin ( )
{
Assert ( s_bCanAccessCurrentView ) ;
return g_vecCurrentRenderOrigin ;
}
const QAngle & CurrentViewAngles ( )
{
Assert ( s_bCanAccessCurrentView ) ;
return g_vecCurrentRenderAngles ;
}
const Vector & CurrentViewForward ( )
{
Assert ( s_bCanAccessCurrentView ) ;
return g_vecCurrentVForward ;
}
const Vector & CurrentViewRight ( )
{
Assert ( s_bCanAccessCurrentView ) ;
return g_vecCurrentVRight ;
}
const Vector & CurrentViewUp ( )
{
Assert ( s_bCanAccessCurrentView ) ;
return g_vecCurrentVUp ;
}
const VMatrix & CurrentWorldToViewMatrix ( )
{
Assert ( s_bCanAccessCurrentView ) ;
return g_matCurrentCamInverse ;
}
//-----------------------------------------------------------------------------
// Methods to set the current view/guard access to view parameters
//-----------------------------------------------------------------------------
void AllowCurrentViewAccess ( bool allow )
{
s_bCanAccessCurrentView = allow ;
}
bool IsCurrentViewAccessAllowed ( )
{
return s_bCanAccessCurrentView ;
}
void SetupCurrentView ( const Vector & vecOrigin , const QAngle & angles , view_id_t viewID )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
// Store off view origin and angles
g_vecCurrentRenderOrigin = vecOrigin ;
g_vecCurrentRenderAngles = angles ;
// Compute the world->main camera transform
ComputeCameraVariables ( vecOrigin , angles ,
& g_vecCurrentVForward , & g_vecCurrentVRight , & g_vecCurrentVUp , & g_matCurrentCamInverse ) ;
g_CurrentViewID = viewID ;
s_bCanAccessCurrentView = true ;
// Cache off fade distances
float flScreenFadeMinSize , flScreenFadeMaxSize ;
view - > GetScreenFadeDistances ( & flScreenFadeMinSize , & flScreenFadeMaxSize ) ;
modelinfo - > SetViewScreenFadeRange ( flScreenFadeMinSize , flScreenFadeMaxSize ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
# ifdef PORTAL
if ( g_pPortalRender - > GetViewRecursionLevel ( ) = = 0 )
{
pRenderContext - > SetIntRenderingParameter ( INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA , ( ( viewID = = VIEW_MAIN ) | | ( viewID = = VIEW_3DSKY ) ) ? 1 : 0 ) ;
}
# else
pRenderContext - > SetIntRenderingParameter ( INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA , ( ( viewID = = VIEW_MAIN ) | | ( viewID = = VIEW_3DSKY ) ) ? 1 : 0 ) ;
# endif
}
view_id_t CurrentViewID ( )
{
Assert ( g_CurrentViewID ! = VIEW_ILLEGAL ) ;
return ( view_id_t ) g_CurrentViewID ;
}
//-----------------------------------------------------------------------------
// Purpose: Portal views are considered 'Main' views. This function tests a view id
// against all view ids used by portal renderables, as well as the main view.
//-----------------------------------------------------------------------------
bool IsMainView ( view_id_t id )
{
# if defined(PORTAL)
return ( ( id = = VIEW_MAIN ) | | g_pPortalRender - > IsPortalViewID ( id ) ) ;
# else
return ( id = = VIEW_MAIN ) ;
# endif
}
void FinishCurrentView ( )
{
s_bCanAccessCurrentView = false ;
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
void CSimpleRenderExecutor : : AddView ( CRendering3dView * pView )
{
CBase3dView * pPrevRenderer = m_pMainView - > SetActiveRenderer ( pView ) ;
pView - > Draw ( ) ;
m_pMainView - > SetActiveRenderer ( pPrevRenderer ) ;
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CViewRender : : CViewRender ( )
: m_SimpleExecutor ( this )
{
m_flCheapWaterStartDistance = 0.0f ;
m_flCheapWaterEndDistance = 0.1f ;
m_BaseDrawFlags = 0 ;
m_pActiveRenderer = NULL ;
m_pCurrentlyDrawingEntity = NULL ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
inline bool CViewRender : : ShouldDrawEntities ( void )
{
return ( ! m_pDrawEntities | | ( m_pDrawEntities - > GetInt ( ) ! = 0 ) ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Check all conditions which would prevent drawing the view model
// Input : drawViewmodel -
// *viewmodel -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CViewRender : : ShouldDrawViewModel ( bool bDrawViewmodel )
{
if ( ! bDrawViewmodel )
return false ;
if ( ! r_drawviewmodel . GetBool ( ) )
return false ;
if ( C_BasePlayer : : ShouldDrawLocalPlayer ( ) )
return false ;
if ( ! ShouldDrawEntities ( ) )
return false ;
if ( render - > GetViewEntity ( ) > gpGlobals - > maxClients )
return false ;
return true ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CViewRender : : UpdateRefractIfNeededByList ( CUtlVector < IClientRenderable * > & list )
{
int nCount = list . Count ( ) ;
for ( int i = 0 ; i < nCount ; + + i )
{
IClientUnknown * pUnk = list [ i ] - > GetIClientUnknown ( ) ;
Assert ( pUnk ) ;
IClientRenderable * pRenderable = pUnk - > GetClientRenderable ( ) ;
Assert ( pRenderable ) ;
if ( pRenderable - > UsesPowerOfTwoFrameBufferTexture ( ) )
{
UpdateRefractTexture ( ) ;
return true ;
}
}
return false ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CViewRender : : DrawRenderablesInList ( CUtlVector < IClientRenderable * > & list , int flags )
{
Assert ( m_pCurrentlyDrawingEntity = = NULL ) ;
int nCount = list . Count ( ) ;
for ( int i = 0 ; i < nCount ; + + i )
{
IClientUnknown * pUnk = list [ i ] - > GetIClientUnknown ( ) ;
Assert ( pUnk ) ;
IClientRenderable * pRenderable = pUnk - > GetClientRenderable ( ) ;
Assert ( pRenderable ) ;
// Non-view models wanting to render in view model list...
if ( pRenderable - > ShouldDraw ( ) )
{
m_pCurrentlyDrawingEntity = pUnk - > GetBaseEntity ( ) ;
pRenderable - > DrawModel ( STUDIO_RENDER | flags ) ;
}
}
m_pCurrentlyDrawingEntity = NULL ;
}
//-----------------------------------------------------------------------------
// Purpose: Actually draw the view model
// Input : drawViewModel -
//-----------------------------------------------------------------------------
void CViewRender : : DrawViewModels ( const CViewSetup & view , bool drawViewmodel )
{
VPROF ( " CViewRender::DrawViewModel " ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
# ifdef PORTAL //in portal, we'd like a copy of the front buffer without the gun in it for use with the depth doubler
g_pPortalRender - > UpdateDepthDoublerTexture ( view ) ;
# endif
bool bShouldDrawPlayerViewModel = ShouldDrawViewModel ( drawViewmodel ) ;
bool bShouldDrawToolViewModels = ToolsEnabled ( ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
PIXEVENT ( pRenderContext , " DrawViewModels " ) ;
// Restore the matrices
pRenderContext - > MatrixMode ( MATERIAL_PROJECTION ) ;
pRenderContext - > PushMatrix ( ) ;
CViewSetup viewModelSetup ( view ) ;
viewModelSetup . zNear = view . zNearViewmodel ;
viewModelSetup . zFar = view . zFarViewmodel ;
viewModelSetup . fov = view . fovViewmodel ;
viewModelSetup . m_flAspectRatio = engine - > GetScreenAspectRatio ( ) ;
ITexture * pRTColor = NULL ;
ITexture * pRTDepth = NULL ;
if ( view . m_eStereoEye ! = STEREO_EYE_MONO )
{
pRTColor = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( view . m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Color ) ;
pRTDepth = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( view . m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Depth ) ;
}
render - > Push3DView ( viewModelSetup , 0 , pRTColor , GetFrustum ( ) , pRTDepth ) ;
# ifdef PORTAL //the depth range hack doesn't work well enough for the portal mod (and messing with the depth hack values makes some models draw incorrectly)
//step up to a full depth clear if we're extremely close to a portal (in a portal environment)
extern bool LocalPlayerIsCloseToPortal ( void ) ; //defined in C_Portal_Player.cpp, abstracting to a single bool function to remove explicit dependence on c_portal_player.h/cpp, you can define the function as a "return true" in other build configurations at the cost of some perf
bool bUseDepthHack = ! LocalPlayerIsCloseToPortal ( ) ;
if ( ! bUseDepthHack )
pRenderContext - > ClearBuffers ( false , true , false ) ;
# else
const bool bUseDepthHack = true ;
# endif
// FIXME: Add code to read the current depth range
float depthmin = 0.0f ;
float depthmax = 1.0f ;
// HACK HACK: Munge the depth range to prevent view model from poking into walls, etc.
// Force clipped down range
if ( bUseDepthHack )
pRenderContext - > DepthRange ( 0.0f , 0.1f ) ;
if ( bShouldDrawPlayerViewModel | | bShouldDrawToolViewModels )
{
CUtlVector < IClientRenderable * > opaqueViewModelList ( 32 ) ;
CUtlVector < IClientRenderable * > translucentViewModelList ( 32 ) ;
ClientLeafSystem ( ) - > CollateViewModelRenderables ( opaqueViewModelList , translucentViewModelList ) ;
if ( ToolsEnabled ( ) & & ( ! bShouldDrawPlayerViewModel | | ! bShouldDrawToolViewModels ) )
{
int nOpaque = opaqueViewModelList . Count ( ) ;
for ( int i = nOpaque - 1 ; i > = 0 ; - - i )
{
IClientRenderable * pRenderable = opaqueViewModelList [ i ] ;
bool bEntity = pRenderable - > GetIClientUnknown ( ) - > GetBaseEntity ( ) ;
if ( ( bEntity & & ! bShouldDrawPlayerViewModel ) | | ( ! bEntity & & ! bShouldDrawToolViewModels ) )
{
opaqueViewModelList . FastRemove ( i ) ;
}
}
int nTranslucent = translucentViewModelList . Count ( ) ;
for ( int i = nTranslucent - 1 ; i > = 0 ; - - i )
{
IClientRenderable * pRenderable = translucentViewModelList [ i ] ;
bool bEntity = pRenderable - > GetIClientUnknown ( ) - > GetBaseEntity ( ) ;
if ( ( bEntity & & ! bShouldDrawPlayerViewModel ) | | ( ! bEntity & & ! bShouldDrawToolViewModels ) )
{
translucentViewModelList . FastRemove ( i ) ;
}
}
}
if ( ! UpdateRefractIfNeededByList ( opaqueViewModelList ) )
{
UpdateRefractIfNeededByList ( translucentViewModelList ) ;
}
DrawRenderablesInList ( opaqueViewModelList ) ;
DrawRenderablesInList ( translucentViewModelList , STUDIO_TRANSPARENCY ) ;
}
// Reset the depth range to the original values
if ( bUseDepthHack )
pRenderContext - > DepthRange ( depthmin , depthmax ) ;
render - > PopView ( GetFrustum ( ) ) ;
// Restore the matrices
pRenderContext - > MatrixMode ( MATERIAL_PROJECTION ) ;
pRenderContext - > PopMatrix ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CViewRender : : ShouldDrawBrushModels ( void )
{
if ( m_pDrawBrushModels & & ! m_pDrawBrushModels - > GetInt ( ) )
return false ;
return true ;
}
//-----------------------------------------------------------------------------
// Purpose: Performs screen space effects, if any
//-----------------------------------------------------------------------------
void CViewRender : : PerformScreenSpaceEffects ( int x , int y , int w , int h )
{
VPROF ( " CViewRender::PerformScreenSpaceEffects() " ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
// FIXME: Screen-space effects are busted in the editor
if ( engine - > IsHammerRunning ( ) )
return ;
g_pScreenSpaceEffects - > RenderEffects ( x , y , w , h ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the screen space effect material (can't be done during rendering)
//-----------------------------------------------------------------------------
void CViewRender : : SetScreenOverlayMaterial ( IMaterial * pMaterial )
{
m_ScreenOverlayMaterial . Init ( pMaterial ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
IMaterial * CViewRender : : GetScreenOverlayMaterial ( )
{
return m_ScreenOverlayMaterial ;
}
//-----------------------------------------------------------------------------
// Purpose: Performs screen space effects, if any
//-----------------------------------------------------------------------------
void CViewRender : : PerformScreenOverlay ( int x , int y , int w , int h )
{
VPROF ( " CViewRender::PerformScreenOverlay() " ) ;
if ( m_ScreenOverlayMaterial )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
if ( m_ScreenOverlayMaterial - > NeedsFullFrameBufferTexture ( ) )
{
// FIXME: check with multi/sub-rect renders. Should this be 0,0,w,h instead?
DrawScreenEffectMaterial ( m_ScreenOverlayMaterial , x , y , w , h ) ;
}
else if ( m_ScreenOverlayMaterial - > NeedsPowerOfTwoFrameBufferTexture ( ) )
{
// First copy the FB off to the offscreen texture
UpdateRefractTexture ( x , y , w , h , true ) ;
// Now draw the entire screen using the material...
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * pTexture = GetPowerOfTwoFrameBufferTexture ( ) ;
int sw = pTexture - > GetActualWidth ( ) ;
int sh = pTexture - > GetActualHeight ( ) ;
// Note - don't offset by x,y - already done by the viewport.
pRenderContext - > DrawScreenSpaceRectangle ( m_ScreenOverlayMaterial , 0 , 0 , w , h ,
0 , 0 , sw - 1 , sh - 1 , sw , sh ) ;
}
else
{
byte color [ 4 ] = { 255 , 255 , 255 , 255 } ;
render - > ViewDrawFade ( color , m_ScreenOverlayMaterial ) ;
}
}
}
void CViewRender : : DrawUnderwaterOverlay ( void )
{
IMaterial * pOverlayMat = m_UnderWaterOverlayMaterial ;
if ( pOverlayMat )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
int x , y , w , h ;
pRenderContext - > GetViewport ( x , y , w , h ) ;
if ( pOverlayMat - > NeedsFullFrameBufferTexture ( ) )
{
// FIXME: check with multi/sub-rect renders. Should this be 0,0,w,h instead?
DrawScreenEffectMaterial ( pOverlayMat , x , y , w , h ) ;
}
else if ( pOverlayMat - > NeedsPowerOfTwoFrameBufferTexture ( ) )
{
// First copy the FB off to the offscreen texture
UpdateRefractTexture ( x , y , w , h , true ) ;
// Now draw the entire screen using the material...
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * pTexture = GetPowerOfTwoFrameBufferTexture ( ) ;
int sw = pTexture - > GetActualWidth ( ) ;
int sh = pTexture - > GetActualHeight ( ) ;
// Note - don't offset by x,y - already done by the viewport.
pRenderContext - > DrawScreenSpaceRectangle ( pOverlayMat , 0 , 0 , w , h ,
0 , 0 , sw - 1 , sh - 1 , sw , sh ) ;
}
else
{
// Note - don't offset by x,y - already done by the viewport.
// FIXME: actually test this code path.
pRenderContext - > DrawScreenSpaceRectangle ( pOverlayMat , 0 , 0 , w , h ,
0 , 0 , 1 , 1 , 1 , 1 ) ;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns the min/max fade distances
//-----------------------------------------------------------------------------
void CViewRender : : GetScreenFadeDistances ( float * min , float * max )
{
if ( min )
{
* min = r_screenfademinsize . GetFloat ( ) ;
}
if ( max )
{
* max = r_screenfademaxsize . GetFloat ( ) ;
}
}
C_BaseEntity * CViewRender : : GetCurrentlyDrawingEntity ( )
{
return m_pCurrentlyDrawingEntity ;
}
void CViewRender : : SetCurrentlyDrawingEntity ( C_BaseEntity * pEnt )
{
m_pCurrentlyDrawingEntity = pEnt ;
}
bool CViewRender : : UpdateShadowDepthTexture ( ITexture * pRenderTarget , ITexture * pDepthTexture , const CViewSetup & shadowViewIn )
{
VPROF_INCREMENT_COUNTER ( " shadow depth textures rendered " , 1 ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
char szPIXEventName [ 128 ] ;
sprintf ( szPIXEventName , " UpdateShadowDepthTexture (%s) " , pDepthTexture - > GetName ( ) ) ;
PIXEVENT ( pRenderContext , szPIXEventName ) ;
CRefPtr < CShadowDepthView > pShadowDepthView = new CShadowDepthView ( this ) ;
pShadowDepthView - > Setup ( shadowViewIn , pRenderTarget , pDepthTexture ) ;
AddViewToScene ( pShadowDepthView ) ;
return true ;
}
//-----------------------------------------------------------------------------
// Purpose: Renders world and all entities, etc.
//-----------------------------------------------------------------------------
void CViewRender : : ViewDrawScene ( bool bDrew3dSkybox , SkyboxVisibility_t nSkyboxVisible , const CViewSetup & view ,
int nClearFlags , view_id_t viewID , bool bDrawViewModel , int baseDrawFlags , ViewCustomVisibility_t * pCustomVisibility )
{
VPROF ( " CViewRender::ViewDrawScene " ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
// this allows the refract texture to be updated once per *scene* on 360
// (e.g. once for a monitor scene and once for the main scene)
g_viewscene_refractUpdateFrame = gpGlobals - > framecount - 1 ;
g_pClientShadowMgr - > PreRender ( ) ;
// Shadowed flashlights supported on ps_2_b and up...
if ( r_flashlightdepthtexture . GetBool ( ) & & ( viewID = = VIEW_MAIN ) )
{
g_pClientShadowMgr - > ComputeShadowDepthTextures ( view ) ;
}
m_BaseDrawFlags = baseDrawFlags ;
SetupCurrentView ( view . origin , view . angles , viewID ) ;
// Invoke pre-render methods
IGameSystem : : PreRenderAllSystems ( ) ;
// Start view
unsigned int visFlags ;
SetupVis ( view , visFlags , pCustomVisibility ) ;
if ( ! bDrew3dSkybox & &
( nSkyboxVisible = = SKYBOX_NOT_VISIBLE ) & & ( visFlags & IVRenderView : : VIEW_SETUP_VIS_EX_RETURN_FLAGS_USES_RADIAL_VIS ) )
{
// This covers the case where we don't see a 3dskybox, yet radial vis is clipping
// the far plane. Need to clear to fog color in this case.
nClearFlags | = VIEW_CLEAR_COLOR ;
SetClearColorToFogColor ( ) ;
}
bool drawSkybox = r_skybox . GetBool ( ) ;
if ( bDrew3dSkybox | | ( nSkyboxVisible = = SKYBOX_NOT_VISIBLE ) )
{
drawSkybox = false ;
}
ParticleMgr ( ) - > IncrementFrameCode ( ) ;
DrawWorldAndEntities ( drawSkybox , view , nClearFlags , pCustomVisibility ) ;
// Disable fog for the rest of the stuff
DisableFog ( ) ;
// UNDONE: Don't do this with masked brush models, they should probably be in a separate list
// render->DrawMaskEntities()
// Here are the overlays...
CGlowOverlay : : DrawOverlays ( view . m_bCacheFullSceneState ) ;
// issue the pixel visibility tests
if ( IsMainView ( CurrentViewID ( ) ) )
{
PixelVisibility_EndCurrentView ( ) ;
}
// Draw rain..
DrawPrecipitation ( ) ;
// Make sure sound doesn't stutter
engine - > Sound_ExtraUpdate ( ) ;
// Debugging info goes over the top
CDebugViewRender : : Draw3DDebuggingInfo ( view ) ;
// Draw client side effects
// NOTE: These are not sorted against the rest of the frame
clienteffects - > DrawEffects ( gpGlobals - > frametime ) ;
// Mark the frame as locked down for client fx additions
SetFXCreationAllowed ( false ) ;
// Invoke post-render methods
IGameSystem : : PostRenderAllSystems ( ) ;
FinishCurrentView ( ) ;
// Free shadow depth textures for use in future view
if ( r_flashlightdepthtexture . GetBool ( ) )
{
g_pClientShadowMgr - > UnlockAllShadowDepthTextures ( ) ;
}
}
void CheckAndTransitionColor ( float flPercent , float * pColor , float * pLerpToColor )
{
if ( pLerpToColor [ 0 ] ! = pColor [ 0 ] | | pLerpToColor [ 1 ] ! = pColor [ 1 ] | | pLerpToColor [ 2 ] ! = pColor [ 2 ] )
{
float flDestColor [ 3 ] ;
flDestColor [ 0 ] = pLerpToColor [ 0 ] ;
flDestColor [ 1 ] = pLerpToColor [ 1 ] ;
flDestColor [ 2 ] = pLerpToColor [ 2 ] ;
pColor [ 0 ] = FLerp ( pColor [ 0 ] , flDestColor [ 0 ] , flPercent ) ;
pColor [ 1 ] = FLerp ( pColor [ 1 ] , flDestColor [ 1 ] , flPercent ) ;
pColor [ 2 ] = FLerp ( pColor [ 2 ] , flDestColor [ 2 ] , flPercent ) ;
}
else
{
pColor [ 0 ] = pLerpToColor [ 0 ] ;
pColor [ 1 ] = pLerpToColor [ 1 ] ;
pColor [ 2 ] = pLerpToColor [ 2 ] ;
}
}
static void GetFogColorTransition ( fogparams_t * pFogParams , float * pColorPrimary , float * pColorSecondary )
{
if ( ! pFogParams )
return ;
if ( pFogParams - > lerptime > = gpGlobals - > curtime )
{
float flPercent = 1.0f - ( ( pFogParams - > lerptime - gpGlobals - > curtime ) / pFogParams - > duration ) ;
float flPrimaryColorLerp [ 3 ] = { ( float ) pFogParams - > colorPrimaryLerpTo . GetR ( ) , ( float ) pFogParams - > colorPrimaryLerpTo . GetG ( ) , ( float ) pFogParams - > colorPrimaryLerpTo . GetB ( ) } ;
float flSecondaryColorLerp [ 3 ] = { ( float ) pFogParams - > colorSecondaryLerpTo . GetR ( ) , ( float ) pFogParams - > colorSecondaryLerpTo . GetG ( ) , ( float ) pFogParams - > colorSecondaryLerpTo . GetB ( ) } ;
CheckAndTransitionColor ( flPercent , pColorPrimary , flPrimaryColorLerp ) ;
CheckAndTransitionColor ( flPercent , pColorSecondary , flSecondaryColorLerp ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns the fog color to use in rendering the current frame.
//-----------------------------------------------------------------------------
static void GetFogColor ( fogparams_t * pFogParams , float * pColor )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp | | ! pFogParams )
return ;
const char * fogColorString = fog_color . GetString ( ) ;
if ( fog_override . GetInt ( ) & & fogColorString )
{
sscanf ( fogColorString , " %f%f%f " , pColor , pColor + 1 , pColor + 2 ) ;
}
else
{
float flPrimaryColor [ 3 ] = { ( float ) pFogParams - > colorPrimary . GetR ( ) , ( float ) pFogParams - > colorPrimary . GetG ( ) , ( float ) pFogParams - > colorPrimary . GetB ( ) } ;
float flSecondaryColor [ 3 ] = { ( float ) pFogParams - > colorSecondary . GetR ( ) , ( float ) pFogParams - > colorSecondary . GetG ( ) , ( float ) pFogParams - > colorSecondary . GetB ( ) } ;
GetFogColorTransition ( pFogParams , flPrimaryColor , flSecondaryColor ) ;
if ( pFogParams - > blend )
{
//
// Blend between two fog colors based on viewing angle.
// The secondary fog color is at 180 degrees to the primary fog color.
//
Vector forward ;
pbp - > EyeVectors ( & forward , NULL , NULL ) ;
Vector vNormalized = pFogParams - > dirPrimary ;
VectorNormalize ( vNormalized ) ;
pFogParams - > dirPrimary = vNormalized ;
float flBlendFactor = 0.5 * forward . Dot ( pFogParams - > dirPrimary ) + 0.5 ;
// FIXME: convert to linear colorspace
pColor [ 0 ] = flPrimaryColor [ 0 ] * flBlendFactor + flSecondaryColor [ 0 ] * ( 1 - flBlendFactor ) ;
pColor [ 1 ] = flPrimaryColor [ 1 ] * flBlendFactor + flSecondaryColor [ 1 ] * ( 1 - flBlendFactor ) ;
pColor [ 2 ] = flPrimaryColor [ 2 ] * flBlendFactor + flSecondaryColor [ 2 ] * ( 1 - flBlendFactor ) ;
}
else
{
pColor [ 0 ] = flPrimaryColor [ 0 ] ;
pColor [ 1 ] = flPrimaryColor [ 1 ] ;
pColor [ 2 ] = flPrimaryColor [ 2 ] ;
}
}
VectorScale ( pColor , 1.0f / 255.0f , pColor ) ;
}
static float GetFogStart ( fogparams_t * pFogParams )
{
if ( ! pFogParams )
return 0.0f ;
if ( fog_override . GetInt ( ) )
{
if ( fog_start . GetFloat ( ) = = - 1.0f )
{
return pFogParams - > start ;
}
else
{
return fog_start . GetFloat ( ) ;
}
}
else
{
if ( pFogParams - > lerptime > gpGlobals - > curtime )
{
if ( pFogParams - > start ! = pFogParams - > startLerpTo )
{
if ( pFogParams - > lerptime > gpGlobals - > curtime )
{
float flPercent = 1.0f - ( ( pFogParams - > lerptime - gpGlobals - > curtime ) / pFogParams - > duration ) ;
return FLerp ( pFogParams - > start , pFogParams - > startLerpTo , flPercent ) ;
}
else
{
if ( pFogParams - > start ! = pFogParams - > startLerpTo )
{
pFogParams - > start = pFogParams - > startLerpTo ;
}
}
}
}
return pFogParams - > start ;
}
}
static float GetFogEnd ( fogparams_t * pFogParams )
{
if ( ! pFogParams )
return 0.0f ;
if ( fog_override . GetInt ( ) )
{
if ( fog_end . GetFloat ( ) = = - 1.0f )
{
return pFogParams - > end ;
}
else
{
return fog_end . GetFloat ( ) ;
}
}
else
{
if ( pFogParams - > lerptime > gpGlobals - > curtime )
{
if ( pFogParams - > end ! = pFogParams - > endLerpTo )
{
if ( pFogParams - > lerptime > gpGlobals - > curtime )
{
float flPercent = 1.0f - ( ( pFogParams - > lerptime - gpGlobals - > curtime ) / pFogParams - > duration ) ;
return FLerp ( pFogParams - > end , pFogParams - > endLerpTo , flPercent ) ;
}
else
{
if ( pFogParams - > end ! = pFogParams - > endLerpTo )
{
pFogParams - > end = pFogParams - > endLerpTo ;
}
}
}
}
return pFogParams - > end ;
}
}
static bool GetFogEnable ( fogparams_t * pFogParams )
{
if ( cl_leveloverview . GetFloat ( ) > 0 )
return false ;
// Ask the clientmode
if ( g_pClientMode - > ShouldDrawFog ( ) = = false )
return false ;
if ( fog_override . GetInt ( ) )
{
if ( fog_enable . GetInt ( ) )
{
return true ;
}
else
{
return false ;
}
}
else
{
if ( pFogParams )
return pFogParams - > enable ! = false ;
return false ;
}
}
static float GetFogMaxDensity ( fogparams_t * pFogParams )
{
if ( ! pFogParams )
return 1.0f ;
if ( cl_leveloverview . GetFloat ( ) > 0 )
return 1.0f ;
// Ask the clientmode
if ( ! g_pClientMode - > ShouldDrawFog ( ) )
return 1.0f ;
if ( fog_override . GetInt ( ) )
{
if ( fog_maxdensity . GetFloat ( ) = = - 1.0f )
return pFogParams - > maxdensity ;
else
return fog_maxdensity . GetFloat ( ) ;
}
else
return pFogParams - > maxdensity ;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the skybox fog color to use in rendering the current frame.
//-----------------------------------------------------------------------------
static void GetSkyboxFogColor ( float * pColor )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp )
{
return ;
}
CPlayerLocalData * local = & pbp - > m_Local ;
const char * fogColorString = fog_colorskybox . GetString ( ) ;
if ( fog_override . GetInt ( ) & & fogColorString )
{
sscanf ( fogColorString , " %f%f%f " , pColor , pColor + 1 , pColor + 2 ) ;
}
else
{
if ( local - > m_skybox3d . fog . blend )
{
//
// Blend between two fog colors based on viewing angle.
// The secondary fog color is at 180 degrees to the primary fog color.
//
Vector forward ;
pbp - > EyeVectors ( & forward , NULL , NULL ) ;
Vector vNormalized = local - > m_skybox3d . fog . dirPrimary ;
VectorNormalize ( vNormalized ) ;
local - > m_skybox3d . fog . dirPrimary = vNormalized ;
float flBlendFactor = 0.5 * forward . Dot ( local - > m_skybox3d . fog . dirPrimary ) + 0.5 ;
// FIXME: convert to linear colorspace
pColor [ 0 ] = local - > m_skybox3d . fog . colorPrimary . GetR ( ) * flBlendFactor + local - > m_skybox3d . fog . colorSecondary . GetR ( ) * ( 1 - flBlendFactor ) ;
pColor [ 1 ] = local - > m_skybox3d . fog . colorPrimary . GetG ( ) * flBlendFactor + local - > m_skybox3d . fog . colorSecondary . GetG ( ) * ( 1 - flBlendFactor ) ;
pColor [ 2 ] = local - > m_skybox3d . fog . colorPrimary . GetB ( ) * flBlendFactor + local - > m_skybox3d . fog . colorSecondary . GetB ( ) * ( 1 - flBlendFactor ) ;
}
else
{
pColor [ 0 ] = local - > m_skybox3d . fog . colorPrimary . GetR ( ) ;
pColor [ 1 ] = local - > m_skybox3d . fog . colorPrimary . GetG ( ) ;
pColor [ 2 ] = local - > m_skybox3d . fog . colorPrimary . GetB ( ) ;
}
}
VectorScale ( pColor , 1.0f / 255.0f , pColor ) ;
}
static float GetSkyboxFogStart ( void )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp )
{
return 0.0f ;
}
CPlayerLocalData * local = & pbp - > m_Local ;
if ( fog_override . GetInt ( ) )
{
if ( fog_startskybox . GetFloat ( ) = = - 1.0f )
{
return local - > m_skybox3d . fog . start ;
}
else
{
return fog_startskybox . GetFloat ( ) ;
}
}
else
{
return local - > m_skybox3d . fog . start ;
}
}
static float GetSkyboxFogEnd ( void )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp )
{
return 0.0f ;
}
CPlayerLocalData * local = & pbp - > m_Local ;
if ( fog_override . GetInt ( ) )
{
if ( fog_endskybox . GetFloat ( ) = = - 1.0f )
{
return local - > m_skybox3d . fog . end ;
}
else
{
return fog_endskybox . GetFloat ( ) ;
}
}
else
{
return local - > m_skybox3d . fog . end ;
}
}
static float GetSkyboxFogMaxDensity ( )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp )
return 1.0f ;
CPlayerLocalData * local = & pbp - > m_Local ;
if ( cl_leveloverview . GetFloat ( ) > 0 )
return 1.0f ;
// Ask the clientmode
if ( ! g_pClientMode - > ShouldDrawFog ( ) )
return 1.0f ;
if ( fog_override . GetInt ( ) )
{
if ( fog_maxdensityskybox . GetFloat ( ) = = - 1.0f )
return local - > m_skybox3d . fog . maxdensity ;
else
return fog_maxdensityskybox . GetFloat ( ) ;
}
else
return local - > m_skybox3d . fog . maxdensity ;
}
void CViewRender : : DisableFog ( void )
{
VPROF ( " CViewRander::DisableFog() " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > FogMode ( MATERIAL_FOG_NONE ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CViewRender : : SetupVis ( const CViewSetup & view , unsigned int & visFlags , ViewCustomVisibility_t * pCustomVisibility )
{
VPROF ( " CViewRender::SetupVis " ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
if ( pCustomVisibility & & pCustomVisibility - > m_nNumVisOrigins )
{
// Pass array or vis origins to merge
render - > ViewSetupVisEx ( ShouldForceNoVis ( ) , pCustomVisibility - > m_nNumVisOrigins , pCustomVisibility - > m_rgVisOrigins , visFlags ) ;
}
else
{
// Use render origin as vis origin by default
render - > ViewSetupVisEx ( ShouldForceNoVis ( ) , 1 , & view . origin , visFlags ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose: Renders voice feedback and other sprites attached to players
// Input : none
//-----------------------------------------------------------------------------
void CViewRender : : RenderPlayerSprites ( )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
GetClientVoiceMgr ( ) - > DrawHeadLabels ( ) ;
}
//-----------------------------------------------------------------------------
// Sets up, cleans up the main 3D view
//-----------------------------------------------------------------------------
void CViewRender : : SetupMain3DView ( const CViewSetup & view , int & nClearFlags )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
// FIXME: I really want these fields removed from CViewSetup
// and passed in as independent flags
// Clear the color here if requested.
int nDepthStencilFlags = nClearFlags & ( VIEW_CLEAR_DEPTH | VIEW_CLEAR_STENCIL ) ;
nClearFlags & = ~ ( nDepthStencilFlags ) ; // Clear these flags
if ( nClearFlags & VIEW_CLEAR_COLOR )
{
nClearFlags | = nDepthStencilFlags ; // Add them back in if we're clearing color
}
// If we are using HDR, we render to the HDR full frame buffer texture
// instead of whatever was previously the render target
if ( g_pMaterialSystemHardwareConfig - > GetHDRType ( ) = = HDR_TYPE_FLOAT )
{
render - > Push3DView ( view , nClearFlags , GetFullFrameFrameBufferTexture ( 0 ) , GetFrustum ( ) ) ;
}
else
{
ITexture * pRTColor = NULL ;
ITexture * pRTDepth = NULL ;
if ( view . m_eStereoEye ! = STEREO_EYE_MONO )
{
pRTColor = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( view . m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Color ) ;
pRTDepth = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( view . m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Depth ) ;
}
render - > Push3DView ( view , nClearFlags , pRTColor , GetFrustum ( ) , pRTDepth ) ;
}
// If we didn't clear the depth here, we'll need to clear it later
nClearFlags ^ = nDepthStencilFlags ; // Toggle these bits
if ( nClearFlags & VIEW_CLEAR_COLOR )
{
// If we cleared the color here, we don't need to clear it later
nClearFlags & = ~ ( VIEW_CLEAR_COLOR | VIEW_CLEAR_FULL_TARGET ) ;
}
}
void CViewRender : : CleanupMain3DView ( const CViewSetup & view )
{
render - > PopView ( GetFrustum ( ) ) ;
}
//-----------------------------------------------------------------------------
// Queues up an overlay rendering
//-----------------------------------------------------------------------------
void CViewRender : : QueueOverlayRenderView ( const CViewSetup & view , int nClearFlags , int whatToDraw )
{
// Can't have 2 in a single scene
Assert ( ! m_bDrawOverlay ) ;
m_bDrawOverlay = true ;
m_OverlayViewSetup = view ;
m_OverlayClearFlags = nClearFlags ;
m_OverlayDrawFlags = whatToDraw ;
}
//-----------------------------------------------------------------------------
// Purpose: Force the view to freeze on the next frame for the specified time
//-----------------------------------------------------------------------------
void CViewRender : : FreezeFrame ( float flFreezeTime )
{
if ( flFreezeTime = = 0 )
{
m_flFreezeFrameUntil = 0 ;
for ( int i = 0 ; i < STEREO_EYE_MAX ; i + + )
{
m_rbTakeFreezeFrame [ i ] = false ;
}
}
else
{
if ( m_flFreezeFrameUntil > gpGlobals - > curtime )
{
m_flFreezeFrameUntil + = flFreezeTime ;
}
else
{
m_flFreezeFrameUntil = gpGlobals - > curtime + flFreezeTime ;
for ( int i = GetFirstEye ( ) ; i < = GetLastEye ( ) ; i + + )
{
m_rbTakeFreezeFrame [ i ] = true ;
}
}
}
}
const char * COM_GetModDirectory ( ) ;
//-----------------------------------------------------------------------------
// Purpose: This renders the entire 3D view and the in-game hud/viewmodel
// Input : &view -
// whatToDraw -
//-----------------------------------------------------------------------------
// This renders the entire 3D view.
void CViewRender : : RenderView ( const CViewSetup & view , int nClearFlags , int whatToDraw )
{
m_UnderWaterOverlayMaterial . Shutdown ( ) ; // underwater view will set
m_CurrentView = view ;
C_BaseAnimating : : AutoAllowBoneAccess boneaccess ( true , true ) ;
VPROF ( " CViewRender::RenderView " ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
// Don't want TF2 running less than DX 8
if ( g_pMaterialSystemHardwareConfig - > GetDXSupportLevel ( ) < 80 )
{
// We know they were running at least 8.0 when the game started...we check the
// value in ClientDLL_Init()...so they must be messing with their DirectX settings.
if ( ( Q_stricmp ( COM_GetModDirectory ( ) , " tf " ) = = 0 ) | | ( Q_stricmp ( COM_GetModDirectory ( ) , " tf_beta " ) = = 0 ) )
{
static bool bFirstTime = true ;
if ( bFirstTime )
{
bFirstTime = false ;
Msg ( " This game has a minimum requirement of DirectX 8.0 to run properly. \n " ) ;
}
return ;
}
}
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * saveRenderTarget = pRenderContext - > GetRenderTarget ( ) ;
pRenderContext . SafeRelease ( ) ; // don't want to hold for long periods in case in a locking active share thread mode
if ( ! m_rbTakeFreezeFrame [ view . m_eStereoEye ] & & m_flFreezeFrameUntil > gpGlobals - > curtime )
{
CRefPtr < CFreezeFrameView > pFreezeFrameView = new CFreezeFrameView ( this ) ;
pFreezeFrameView - > Setup ( view ) ;
AddViewToScene ( pFreezeFrameView ) ;
g_bRenderingView = true ;
s_bCanAccessCurrentView = true ;
}
else
{
g_flFreezeFlash = 0.0f ;
g_pClientShadowMgr - > AdvanceFrame ( ) ;
# ifdef USE_MONITORS
if ( cl_drawmonitors . GetBool ( ) & &
( g_pMaterialSystemHardwareConfig - > GetDXSupportLevel ( ) > = 70 ) & &
( ( whatToDraw & RENDERVIEW_SUPPRESSMONITORRENDERING ) = = 0 ) )
{
CViewSetup viewMiddle = GetView ( STEREO_EYE_MONO ) ;
DrawMonitors ( viewMiddle ) ;
}
# endif
g_bRenderingView = true ;
// Must be first
render - > SceneBegin ( ) ;
pRenderContext . GetFrom ( materials ) ;
pRenderContext - > TurnOnToneMapping ( ) ;
pRenderContext . SafeRelease ( ) ;
// clear happens here probably
SetupMain3DView ( view , nClearFlags ) ;
bool bDrew3dSkybox = false ;
SkyboxVisibility_t nSkyboxVisible = SKYBOX_NOT_VISIBLE ;
// if the 3d skybox world is drawn, then don't draw the normal skybox
CSkyboxView * pSkyView = new CSkyboxView ( this ) ;
if ( ( bDrew3dSkybox = pSkyView - > Setup ( view , & nClearFlags , & nSkyboxVisible ) ) ! = false )
{
AddViewToScene ( pSkyView ) ;
}
SafeRelease ( pSkyView ) ;
// Force it to clear the framebuffer if they're in solid space.
if ( ( nClearFlags & VIEW_CLEAR_COLOR ) = = 0 )
{
if ( enginetrace - > GetPointContents ( view . origin ) = = CONTENTS_SOLID )
{
nClearFlags | = VIEW_CLEAR_COLOR ;
}
}
// Render world and all entities, particles, etc.
if ( ! g_pIntroData )
{
ViewDrawScene ( bDrew3dSkybox , nSkyboxVisible , view , nClearFlags , VIEW_MAIN , whatToDraw & RENDERVIEW_DRAWVIEWMODEL ) ;
}
else
{
ViewDrawScene_Intro ( view , nClearFlags , * g_pIntroData ) ;
}
// We can still use the 'current view' stuff set up in ViewDrawScene
s_bCanAccessCurrentView = true ;
engine - > DrawPortals ( ) ;
DisableFog ( ) ;
// Finish scene
render - > SceneEnd ( ) ;
// Draw lightsources if enabled
render - > DrawLights ( ) ;
RenderPlayerSprites ( ) ;
// Image-space motion blur
if ( ! building_cubemaps . GetBool ( ) & & view . m_bDoBloomAndToneMapping ) // We probably should use a different view. variable here
{
if ( ( mat_motion_blur_enabled . GetInt ( ) ) & & ( g_pMaterialSystemHardwareConfig - > GetDXSupportLevel ( ) > = 90 ) )
{
pRenderContext . GetFrom ( materials ) ;
{
PIXEVENT ( pRenderContext , " DoImageSpaceMotionBlur " ) ;
DoImageSpaceMotionBlur ( view , view . x , view . y , view . width , view . height ) ;
}
pRenderContext . SafeRelease ( ) ;
}
}
GetClientModeNormal ( ) - > DoPostScreenSpaceEffects ( & view ) ;
// Now actually draw the viewmodel
DrawViewModels ( view , whatToDraw & RENDERVIEW_DRAWVIEWMODEL ) ;
DrawUnderwaterOverlay ( ) ;
PixelVisibility_EndScene ( ) ;
// Draw fade over entire screen if needed
byte color [ 4 ] ;
bool blend ;
vieweffects - > GetFadeParams ( & color [ 0 ] , & color [ 1 ] , & color [ 2 ] , & color [ 3 ] , & blend ) ;
// Draw an overlay to make it even harder to see inside smoke particle systems.
DrawSmokeFogOverlay ( ) ;
// Overlay screen fade on entire screen
IMaterial * pMaterial = blend ? m_ModulateSingleColor : m_TranslucentSingleColor ;
render - > ViewDrawFade ( color , pMaterial ) ;
PerformScreenOverlay ( view . x , view . y , view . width , view . height ) ;
// Prevent sound stutter if going slow
engine - > Sound_ExtraUpdate ( ) ;
if ( ! building_cubemaps . GetBool ( ) & & view . m_bDoBloomAndToneMapping )
{
pRenderContext . GetFrom ( materials ) ;
{
PIXEVENT ( pRenderContext , " DoEnginePostProcessing " ) ;
bool bFlashlightIsOn = false ;
C_BasePlayer * pLocal = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( pLocal )
{
bFlashlightIsOn = pLocal - > IsEffectActive ( EF_DIMLIGHT ) ;
}
DoEnginePostProcessing ( view . x , view . y , view . width , view . height , bFlashlightIsOn ) ;
}
pRenderContext . SafeRelease ( ) ;
}
// And here are the screen-space effects
if ( IsPC ( ) )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " GrabPreColorCorrectedFrame " ) ;
// Grab the pre-color corrected frame for editing purposes
engine - > GrabPreColorCorrectedFrame ( view . x , view . y , view . width , view . height ) ;
}
PerformScreenSpaceEffects ( 0 , 0 , view . width , view . height ) ;
if ( g_pMaterialSystemHardwareConfig - > GetHDRType ( ) = = HDR_TYPE_INTEGER )
{
pRenderContext . GetFrom ( materials ) ;
pRenderContext - > SetToneMappingScaleLinear ( Vector ( 1 , 1 , 1 ) ) ;
pRenderContext . SafeRelease ( ) ;
}
CleanupMain3DView ( view ) ;
if ( m_rbTakeFreezeFrame [ view . m_eStereoEye ] )
{
Rect_t rect ;
rect . x = view . x ;
rect . y = view . y ;
rect . width = view . width ;
rect . height = view . height ;
pRenderContext = materials - > GetRenderContext ( ) ;
if ( IsX360 ( ) )
{
// 360 doesn't create the Fullscreen texture
pRenderContext - > CopyRenderTargetToTextureEx ( GetFullFrameFrameBufferTexture ( 1 ) , 0 , & rect , & rect ) ;
}
else
{
pRenderContext - > CopyRenderTargetToTextureEx ( GetFullscreenTexture ( ) , 0 , & rect , & rect ) ;
}
pRenderContext . SafeRelease ( ) ;
m_rbTakeFreezeFrame [ view . m_eStereoEye ] = false ;
}
pRenderContext = materials - > GetRenderContext ( ) ;
pRenderContext - > SetRenderTarget ( saveRenderTarget ) ;
pRenderContext . SafeRelease ( ) ;
// Draw the overlay
if ( m_bDrawOverlay )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " DrawOverlay " ) ;
// This allows us to be ok if there are nested overlay views
CViewSetup currentView = m_CurrentView ;
CViewSetup tempView = m_OverlayViewSetup ;
tempView . fov = ScaleFOVByWidthRatio ( tempView . fov , tempView . m_flAspectRatio / ( 4.0f / 3.0f ) ) ;
tempView . m_bDoBloomAndToneMapping = false ; // FIXME: Hack to get Mark up and running
m_bDrawOverlay = false ;
RenderView ( tempView , m_OverlayClearFlags , m_OverlayDrawFlags ) ;
m_CurrentView = currentView ;
}
}
if ( mat_viewportupscale . GetBool ( ) & & mat_viewportscale . GetFloat ( ) < 1.0f )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * pFullFrameFB1 = materials - > FindTexture ( " _rt_FullFrameFB1 " , TEXTURE_GROUP_RENDER_TARGET ) ;
IMaterial * pCopyMaterial = materials - > FindMaterial ( " dev/upscale " , TEXTURE_GROUP_OTHER ) ;
pCopyMaterial - > IncrementReferenceCount ( ) ;
Rect_t DownscaleRect , UpscaleRect ;
DownscaleRect . x = view . x ;
DownscaleRect . y = view . y ;
DownscaleRect . width = view . width ;
DownscaleRect . height = view . height ;
UpscaleRect . x = view . m_nUnscaledX ;
UpscaleRect . y = view . m_nUnscaledY ;
UpscaleRect . width = view . m_nUnscaledWidth ;
UpscaleRect . height = view . m_nUnscaledHeight ;
pRenderContext - > CopyRenderTargetToTextureEx ( pFullFrameFB1 , 0 , & DownscaleRect , & DownscaleRect ) ;
pRenderContext - > DrawScreenSpaceRectangle ( pCopyMaterial , UpscaleRect . x , UpscaleRect . y , UpscaleRect . width , UpscaleRect . height ,
DownscaleRect . x , DownscaleRect . y , DownscaleRect . x + DownscaleRect . width - 1 , DownscaleRect . y + DownscaleRect . height - 1 ,
pFullFrameFB1 - > GetActualWidth ( ) , pFullFrameFB1 - > GetActualHeight ( ) ) ;
pCopyMaterial - > DecrementReferenceCount ( ) ;
}
// if we're in VR mode we might need to override the render target
if ( UseVR ( ) )
{
saveRenderTarget = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( view . m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Color ) ;
}
// Draw the 2D graphics
render - > Push2DView ( view , 0 , saveRenderTarget , GetFrustum ( ) ) ;
Render2DEffectsPreHUD ( view ) ;
if ( whatToDraw & RENDERVIEW_DRAWHUD )
{
VPROF_BUDGET ( " VGui_DrawHud " , VPROF_BUDGETGROUP_OTHER_VGUI ) ;
int viewWidth = view . m_nUnscaledWidth ;
int viewHeight = view . m_nUnscaledHeight ;
int viewActualWidth = view . m_nUnscaledWidth ;
int viewActualHeight = view . m_nUnscaledHeight ;
int viewX = view . m_nUnscaledX ;
int viewY = view . m_nUnscaledY ;
int viewFramebufferX = 0 ;
int viewFramebufferY = 0 ;
int viewFramebufferWidth = viewWidth ;
int viewFramebufferHeight = viewHeight ;
bool bClear = false ;
bool bPaintMainMenu = false ;
ITexture * pTexture = NULL ;
if ( UseVR ( ) )
{
if ( g_ClientVirtualReality . ShouldRenderHUDInWorld ( ) )
{
pTexture = materials - > FindTexture ( " _rt_gui " , NULL , false ) ;
if ( pTexture )
{
bPaintMainMenu = true ;
bClear = true ;
viewX = 0 ;
viewY = 0 ;
viewActualWidth = pTexture - > GetActualWidth ( ) ;
viewActualHeight = pTexture - > GetActualHeight ( ) ;
vgui : : surface ( ) - > GetScreenSize ( viewWidth , viewHeight ) ;
viewFramebufferX = 0 ;
if ( view . m_eStereoEye = = STEREO_EYE_RIGHT & & ! saveRenderTarget )
viewFramebufferX = viewFramebufferWidth ;
viewFramebufferY = 0 ;
}
}
else
{
viewFramebufferX = view . m_eStereoEye = = STEREO_EYE_RIGHT ? viewWidth : 0 ;
viewFramebufferY = 0 ;
}
}
// Get the render context out of materials to avoid some debug stuff.
// WARNING THIS REQUIRES THE .SafeRelease below or it'll never release the ref
pRenderContext = materials - > GetRenderContext ( ) ;
// clear depth in the backbuffer before we push the render target
if ( bClear )
{
pRenderContext - > ClearBuffers ( false , true , true ) ;
}
// constrain where VGUI can render to the view
pRenderContext - > PushRenderTargetAndViewport ( pTexture , NULL , viewX , viewY , viewActualWidth , viewActualHeight ) ;
// If drawing off-screen, force alpha for that pass
if ( pTexture )
{
pRenderContext - > OverrideAlphaWriteEnable ( true , true ) ;
}
// let vgui know where to render stuff for the forced-to-framebuffer panels
if ( UseVR ( ) )
{
g_pMatSystemSurface - > SetFullscreenViewportAndRenderTarget ( viewFramebufferX , viewFramebufferY , viewFramebufferWidth , viewFramebufferHeight , saveRenderTarget ) ;
}
// clear the render target if we need to
if ( bClear )
{
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 0 ) ;
pRenderContext - > ClearBuffers ( true , false ) ;
}
pRenderContext . SafeRelease ( ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " VGui_DrawHud " , __FUNCTION__ ) ;
// paint the vgui screen
VGui_PreRender ( ) ;
// Make sure the client .dll root panel is at the proper point before doing the "SolveTraverse" calls
vgui : : VPANEL root = enginevgui - > GetPanel ( PANEL_CLIENTDLL ) ;
if ( root ! = 0 )
{
vgui : : ipanel ( ) - > SetSize ( root , viewWidth , viewHeight ) ;
}
// Same for client .dll tools
root = enginevgui - > GetPanel ( PANEL_CLIENTDLL_TOOLS ) ;
if ( root ! = 0 )
{
vgui : : ipanel ( ) - > SetSize ( root , viewWidth , viewHeight ) ;
}
// The crosshair, etc. needs to get at the current setup stuff
AllowCurrentViewAccess ( true ) ;
// Draw the in-game stuff based on the actual viewport being used
render - > VGui_Paint ( PAINT_INGAMEPANELS ) ;
// maybe paint the main menu and cursor too if we're in stereo hud mode
if ( bPaintMainMenu )
render - > VGui_Paint ( PAINT_UIPANELS | PAINT_CURSOR ) ;
AllowCurrentViewAccess ( false ) ;
VGui_PostRender ( ) ;
g_pClientMode - > PostRenderVGui ( ) ;
pRenderContext = materials - > GetRenderContext ( ) ;
if ( pTexture )
{
pRenderContext - > OverrideAlphaWriteEnable ( false , true ) ;
}
pRenderContext - > PopRenderTargetAndViewport ( ) ;
if ( UseVR ( ) )
{
// figure out if we really want to draw the HUD based on freeze cam
C_BasePlayer * pPlayer = C_BasePlayer : : GetLocalPlayer ( ) ;
bool bInFreezeCam = ( pPlayer & & pPlayer - > GetObserverMode ( ) = = OBS_MODE_FREEZECAM ) ;
// draw the HUD after the view model so its "I'm closer" depth queues work right.
if ( ! bInFreezeCam & & g_ClientVirtualReality . ShouldRenderHUDInWorld ( ) )
{
// Now we've rendered the HUD to its texture, actually get it on the screen.
// Since we're drawing it as a 3D object, we need correctly set up frustum, etc.
int ClearFlags = 0 ;
SetupMain3DView ( view , ClearFlags ) ;
// TODO - a bit of a shonky test - basically trying to catch the main menu, the briefing screen, the loadout screen, etc.
bool bTranslucent = ! g_pMatSystemSurface - > IsCursorVisible ( ) ;
g_ClientVirtualReality . RenderHUDQuad ( g_pClientMode - > ShouldBlackoutAroundHUD ( ) , bTranslucent ) ;
CleanupMain3DView ( view ) ;
}
}
pRenderContext - > Flush ( ) ;
pRenderContext . SafeRelease ( ) ;
}
CDebugViewRender : : Draw2DDebuggingInfo ( view ) ;
Render2DEffectsPostHUD ( view ) ;
g_bRenderingView = false ;
// We can no longer use the 'current view' stuff set up in ViewDrawScene
s_bCanAccessCurrentView = false ;
if ( IsPC ( ) )
{
CDebugViewRender : : GenerateOverdrawForTesting ( ) ;
}
render - > PopView ( GetFrustum ( ) ) ;
g_WorldListCache . Flush ( ) ;
}
//-----------------------------------------------------------------------------
// Purpose: Renders extra 2D effects in derived classes while the 2D view is on the stack
//-----------------------------------------------------------------------------
void CViewRender : : Render2DEffectsPreHUD ( const CViewSetup & view )
{
}
//-----------------------------------------------------------------------------
// Purpose: Renders extra 2D effects in derived classes while the 2D view is on the stack
//-----------------------------------------------------------------------------
void CViewRender : : Render2DEffectsPostHUD ( const CViewSetup & view )
{
}
//-----------------------------------------------------------------------------
//
// NOTE: Below here is all of the stuff that needs to be done for water rendering
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Determines what kind of water we're going to use
//-----------------------------------------------------------------------------
void CViewRender : : DetermineWaterRenderInfo ( const VisibleFogVolumeInfo_t & fogVolumeInfo , WaterRenderInfo_t & info )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
// By default, assume cheap water (even if there's no water in the scene!)
info . m_bCheapWater = true ;
info . m_bRefract = false ;
info . m_bReflect = false ;
info . m_bReflectEntities = false ;
info . m_bDrawWaterSurface = false ;
info . m_bOpaqueWater = true ;
IMaterial * pWaterMaterial = fogVolumeInfo . m_pFogVolumeMaterial ;
if ( ( fogVolumeInfo . m_nVisibleFogVolume = = - 1 ) | | ! pWaterMaterial )
return ;
// Use cheap water if mat_drawwater is set
info . m_bDrawWaterSurface = mat_drawwater . GetBool ( ) ;
if ( ! info . m_bDrawWaterSurface )
{
info . m_bOpaqueWater = false ;
return ;
}
# ifdef _X360
bool bForceExpensive = false ;
# else
bool bForceExpensive = r_waterforceexpensive . GetBool ( ) ;
# endif
bool bForceReflectEntities = r_waterforcereflectentities . GetBool ( ) ;
# ifdef PORTAL
switch ( g_pPortalRender - > ShouldForceCheaperWaterLevel ( ) )
{
case 0 : //force cheap water
info . m_bCheapWater = true ;
return ;
case 1 : //downgrade level to "simple reflection"
bForceExpensive = false ;
case 2 : //downgrade level to "reflect world"
bForceReflectEntities = false ;
default :
break ;
} ;
# endif
// Determine if the water surface is opaque or not
info . m_bOpaqueWater = ! pWaterMaterial - > IsTranslucent ( ) ;
// DX level 70 can't handle anything but cheap water
if ( engine - > GetDXSupportLevel ( ) < 80 )
return ;
bool bForceCheap = false ;
// The material can override the default settings though
IMaterialVar * pForceCheapVar = pWaterMaterial - > FindVar ( " $forcecheap " , NULL , false ) ;
IMaterialVar * pForceExpensiveVar = pWaterMaterial - > FindVar ( " $forceexpensive " , NULL , false ) ;
if ( pForceCheapVar & & pForceCheapVar - > IsDefined ( ) )
{
bForceCheap = ( pForceCheapVar - > GetIntValueFast ( ) ! = 0 ) ;
if ( bForceCheap )
{
bForceExpensive = false ;
}
}
if ( ! bForceCheap & & pForceExpensiveVar & & pForceExpensiveVar - > IsDefined ( ) )
{
bForceExpensive = bForceExpensive | | ( pForceExpensiveVar - > GetIntValueFast ( ) ! = 0 ) ;
}
bool bDebugCheapWater = r_debugcheapwater . GetBool ( ) ;
if ( bDebugCheapWater )
{
Msg ( " Water material: %s dist to water: %f \n forcecheap: %s forceexpensive: %s \n " ,
pWaterMaterial - > GetName ( ) , fogVolumeInfo . m_flDistanceToWater ,
bForceCheap ? " true " : " false " , bForceExpensive ? " true " : " false " ) ;
}
// Unless expensive water is active, reflections are off.
bool bLocalReflection ;
# ifdef _X360
if ( ! r_WaterDrawReflection . GetBool ( ) )
# else
if ( ! bForceExpensive | | ! r_WaterDrawReflection . GetBool ( ) )
# endif
{
bLocalReflection = false ;
}
else
{
IMaterialVar * pReflectTextureVar = pWaterMaterial - > FindVar ( " $reflecttexture " , NULL , false ) ;
bLocalReflection = pReflectTextureVar & & ( pReflectTextureVar - > GetType ( ) = = MATERIAL_VAR_TYPE_TEXTURE ) ;
}
// Brian says FIXME: I disabled cheap water LOD when local specular is specified.
// There are very few places that appear to actually
// take advantage of it (places where water is in the PVS, but outside of LOD range).
// It was 2 hours before code lock, and I had the choice of either doubling fill-rate everywhere
// by making cheap water lod actually work (the water LOD wasn't actually rendering!!!)
// or to just always render the reflection + refraction if there's a local specular specified.
// Note that water LOD *does* work with refract-only water
// Gary says: I'm reverting this change so that water LOD works on dx9 for ep2.
// Check if the water is out of the cheap water LOD range; if so, use cheap water
# ifdef _X360
if ( ! bForceExpensive & & ( bForceCheap | | ( fogVolumeInfo . m_flDistanceToWater > = m_flCheapWaterEndDistance ) ) )
{
return ;
}
# else
if ( ( ( fogVolumeInfo . m_flDistanceToWater > = m_flCheapWaterEndDistance ) & & ! bLocalReflection ) | | bForceCheap )
return ;
# endif
// Get the material that is for the water surface that is visible and check to see
// what render targets need to be rendered, if any.
if ( ! r_WaterDrawRefraction . GetBool ( ) )
{
info . m_bRefract = false ;
}
else
{
IMaterialVar * pRefractTextureVar = pWaterMaterial - > FindVar ( " $refracttexture " , NULL , false ) ;
info . m_bRefract = pRefractTextureVar & & ( pRefractTextureVar - > GetType ( ) = = MATERIAL_VAR_TYPE_TEXTURE ) ;
// Refractive water can be seen through
if ( info . m_bRefract )
{
info . m_bOpaqueWater = false ;
}
}
info . m_bReflect = bLocalReflection ;
if ( info . m_bReflect )
{
if ( bForceReflectEntities )
{
info . m_bReflectEntities = true ;
}
else
{
IMaterialVar * pReflectEntitiesVar = pWaterMaterial - > FindVar ( " $reflectentities " , NULL , false ) ;
info . m_bReflectEntities = pReflectEntitiesVar & & ( pReflectEntitiesVar - > GetIntValueFast ( ) ! = 0 ) ;
}
}
info . m_bCheapWater = ! info . m_bReflect & & ! info . m_bRefract ;
if ( bDebugCheapWater )
{
Warning ( " refract: %s reflect: %s \n " , info . m_bRefract ? " true " : " false " , info . m_bReflect ? " true " : " false " ) ;
}
}
//-----------------------------------------------------------------------------
// Draws the world and all entities
//-----------------------------------------------------------------------------
void CViewRender : : DrawWorldAndEntities ( bool bDrawSkybox , const CViewSetup & viewIn , int nClearFlags , ViewCustomVisibility_t * pCustomVisibility )
{
MDLCACHE_CRITICAL_SECTION ( ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
VisibleFogVolumeInfo_t fogVolumeInfo ;
# ifdef PORTAL //in portal, we can't use the fog volume for the camera since it's almost never in the same fog volume as what's in front of the portal
if ( g_pPortalRender - > GetViewRecursionLevel ( ) = = 0 )
{
render - > GetVisibleFogVolume ( viewIn . origin , & fogVolumeInfo ) ;
}
else
{
render - > GetVisibleFogVolume ( g_pPortalRender - > GetExitPortalFogOrigin ( ) , & fogVolumeInfo ) ;
}
# else
render - > GetVisibleFogVolume ( viewIn . origin , & fogVolumeInfo ) ;
# endif
WaterRenderInfo_t info ;
DetermineWaterRenderInfo ( fogVolumeInfo , info ) ;
if ( info . m_bCheapWater )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " bCheapWater " ) ;
cplane_t glassReflectionPlane ;
if ( IsReflectiveGlassInView ( viewIn , glassReflectionPlane ) )
{
CRefPtr < CReflectiveGlassView > pGlassReflectionView = new CReflectiveGlassView ( this ) ;
pGlassReflectionView - > Setup ( viewIn , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR , bDrawSkybox , fogVolumeInfo , info , glassReflectionPlane ) ;
AddViewToScene ( pGlassReflectionView ) ;
CRefPtr < CRefractiveGlassView > pGlassRefractionView = new CRefractiveGlassView ( this ) ;
pGlassRefractionView - > Setup ( viewIn , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR , bDrawSkybox , fogVolumeInfo , info , glassReflectionPlane ) ;
AddViewToScene ( pGlassRefractionView ) ;
}
CRefPtr < CSimpleWorldView > pNoWaterView = new CSimpleWorldView ( this ) ;
pNoWaterView - > Setup ( viewIn , nClearFlags , bDrawSkybox , fogVolumeInfo , info , pCustomVisibility ) ;
AddViewToScene ( pNoWaterView ) ;
return ;
}
Assert ( ! pCustomVisibility ) ;
// Blat out the visible fog leaf if we're not going to use it
if ( ! r_ForceWaterLeaf . GetBool ( ) )
{
fogVolumeInfo . m_nVisibleFogVolumeLeaf = - 1 ;
}
// We can see water of some sort
if ( ! fogVolumeInfo . m_bEyeInFogVolume )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " CAboveWaterView " ) ;
CRefPtr < CAboveWaterView > pAboveWaterView = new CAboveWaterView ( this ) ;
pAboveWaterView - > Setup ( viewIn , bDrawSkybox , fogVolumeInfo , info ) ;
AddViewToScene ( pAboveWaterView ) ;
}
else
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " CUnderWaterView " ) ;
CRefPtr < CUnderWaterView > pUnderWaterView = new CUnderWaterView ( this ) ;
pUnderWaterView - > Setup ( viewIn , bDrawSkybox , fogVolumeInfo , info ) ;
AddViewToScene ( pUnderWaterView ) ;
}
}
//-----------------------------------------------------------------------------
// Pushes a water render target
//-----------------------------------------------------------------------------
static Vector SavedLinearLightMapScale ( - 1 , - 1 , - 1 ) ; // x<0 = no saved scale
static void SetLightmapScaleForWater ( void )
{
if ( g_pMaterialSystemHardwareConfig - > GetHDRType ( ) = = HDR_TYPE_INTEGER )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
SavedLinearLightMapScale = pRenderContext - > GetToneMappingScaleLinear ( ) ;
Vector t25 = SavedLinearLightMapScale ;
t25 * = 0.25 ;
pRenderContext - > SetToneMappingScaleLinear ( t25 ) ;
}
}
//-----------------------------------------------------------------------------
// Returns true if the view plane intersects the water
//-----------------------------------------------------------------------------
bool DoesViewPlaneIntersectWater ( float waterZ , int leafWaterDataID )
{
if ( leafWaterDataID = = - 1 )
return false ;
# ifdef PORTAL //when rendering portal views point/plane intersections just don't cut it.
if ( g_pPortalRender - > GetViewRecursionLevel ( ) ! = 0 )
return g_pPortalRender - > DoesExitPortalViewIntersectWaterPlane ( waterZ , leafWaterDataID ) ;
# endif
CMatRenderContextPtr pRenderContext ( materials ) ;
VMatrix viewMatrix , projectionMatrix , viewProjectionMatrix , inverseViewProjectionMatrix ;
pRenderContext - > GetMatrix ( MATERIAL_VIEW , & viewMatrix ) ;
pRenderContext - > GetMatrix ( MATERIAL_PROJECTION , & projectionMatrix ) ;
MatrixMultiply ( projectionMatrix , viewMatrix , viewProjectionMatrix ) ;
MatrixInverseGeneral ( viewProjectionMatrix , inverseViewProjectionMatrix ) ;
Vector mins , maxs ;
ClearBounds ( mins , maxs ) ;
Vector testPoint [ 4 ] ;
testPoint [ 0 ] . Init ( - 1.0f , - 1.0f , 0.0f ) ;
testPoint [ 1 ] . Init ( - 1.0f , 1.0f , 0.0f ) ;
testPoint [ 2 ] . Init ( 1.0f , - 1.0f , 0.0f ) ;
testPoint [ 3 ] . Init ( 1.0f , 1.0f , 0.0f ) ;
int i ;
bool bAbove = false ;
bool bBelow = false ;
float fudge = 7.0f ;
for ( i = 0 ; i < 4 ; i + + )
{
Vector worldPos ;
Vector3DMultiplyPositionProjective ( inverseViewProjectionMatrix , testPoint [ i ] , worldPos ) ;
AddPointToBounds ( worldPos , mins , maxs ) ;
// Warning( "viewplanez: %f waterZ: %f\n", worldPos.z, waterZ );
if ( worldPos . z + fudge > waterZ )
{
bAbove = true ;
}
if ( worldPos . z - fudge < waterZ )
{
bBelow = true ;
}
}
// early out if the near plane doesn't cross the z plane of the water.
if ( ! ( bAbove & & bBelow ) )
return false ;
Vector vecFudge ( fudge , fudge , fudge ) ;
mins - = vecFudge ;
maxs + = vecFudge ;
// the near plane does cross the z value for the visible water volume. Call into
// the engine to find out if the near plane intersects the water volume.
return render - > DoesBoxIntersectWaterVolume ( mins , maxs , leafWaterDataID ) ;
}
# ifdef PORTAL
//-----------------------------------------------------------------------------
// Purpose: Draw the scene during another draw scene call. We must draw our portals
// after opaques but before translucents, so this ViewDrawScene resets the view
// and doesn't flag the rendering as ended when it ends.
// Input : bDrawSkybox - do we draw the skybox
// &view - the camera view to render from
// nClearFlags - how to clear the buffer
//-----------------------------------------------------------------------------
void CViewRender : : ViewDrawScene_PortalStencil ( const CViewSetup & viewIn , ViewCustomVisibility_t * pCustomVisibility )
{
VPROF ( " CViewRender::ViewDrawScene_PortalStencil " ) ;
CViewSetup view ( viewIn ) ;
// Record old view stats
Vector vecOldOrigin = CurrentViewOrigin ( ) ;
QAngle vecOldAngles = CurrentViewAngles ( ) ;
int iCurrentViewID = g_CurrentViewID ;
bool bDrew3dSkybox = false ;
SkyboxVisibility_t nSkyboxVisible = SKYBOX_NOT_VISIBLE ;
int iClearFlags = 0 ;
Draw3dSkyboxworld_Portal ( view , iClearFlags , bDrew3dSkybox , nSkyboxVisible ) ;
bool drawSkybox = r_skybox . GetBool ( ) ;
if ( bDrew3dSkybox | | ( nSkyboxVisible = = SKYBOX_NOT_VISIBLE ) )
{
drawSkybox = false ;
}
//generate unique view ID's for each stencil view
view_id_t iNewViewID = ( view_id_t ) g_pPortalRender - > GetCurrentViewId ( ) ;
SetupCurrentView ( view . origin , view . angles , ( view_id_t ) iNewViewID ) ;
// update vis data
unsigned int visFlags ;
SetupVis ( view , visFlags , pCustomVisibility ) ;
VisibleFogVolumeInfo_t fogInfo ;
if ( g_pPortalRender - > GetViewRecursionLevel ( ) = = 0 )
{
render - > GetVisibleFogVolume ( view . origin , & fogInfo ) ;
}
else
{
render - > GetVisibleFogVolume ( g_pPortalRender - > GetExitPortalFogOrigin ( ) , & fogInfo ) ;
}
WaterRenderInfo_t waterInfo ;
DetermineWaterRenderInfo ( fogInfo , waterInfo ) ;
if ( waterInfo . m_bCheapWater )
{
cplane_t glassReflectionPlane ;
if ( IsReflectiveGlassInView ( viewIn , glassReflectionPlane ) )
{
CRefPtr < CReflectiveGlassView > pGlassReflectionView = new CReflectiveGlassView ( this ) ;
pGlassReflectionView - > Setup ( viewIn , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR | VIEW_CLEAR_OBEY_STENCIL , drawSkybox , fogInfo , waterInfo , glassReflectionPlane ) ;
AddViewToScene ( pGlassReflectionView ) ;
CRefPtr < CRefractiveGlassView > pGlassRefractionView = new CRefractiveGlassView ( this ) ;
pGlassRefractionView - > Setup ( viewIn , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR | VIEW_CLEAR_OBEY_STENCIL , drawSkybox , fogInfo , waterInfo , glassReflectionPlane ) ;
AddViewToScene ( pGlassRefractionView ) ;
}
CSimpleWorldView * pClientView = new CSimpleWorldView ( this ) ;
pClientView - > Setup ( view , VIEW_CLEAR_OBEY_STENCIL , drawSkybox , fogInfo , waterInfo , pCustomVisibility ) ;
AddViewToScene ( pClientView ) ;
SafeRelease ( pClientView ) ;
}
else
{
// We can see water of some sort
if ( ! fogInfo . m_bEyeInFogVolume )
{
CRefPtr < CAboveWaterView > pAboveWaterView = new CAboveWaterView ( this ) ;
pAboveWaterView - > Setup ( viewIn , drawSkybox , fogInfo , waterInfo ) ;
AddViewToScene ( pAboveWaterView ) ;
}
else
{
CRefPtr < CUnderWaterView > pUnderWaterView = new CUnderWaterView ( this ) ;
pUnderWaterView - > Setup ( viewIn , drawSkybox , fogInfo , waterInfo ) ;
AddViewToScene ( pUnderWaterView ) ;
}
}
// Disable fog for the rest of the stuff
DisableFog ( ) ;
CGlowOverlay : : DrawOverlays ( view . m_bCacheFullSceneState ) ;
// Draw rain..
DrawPrecipitation ( ) ;
//prerender version only
// issue the pixel visibility tests
PixelVisibility_EndCurrentView ( ) ;
// Make sure sound doesn't stutter
engine - > Sound_ExtraUpdate ( ) ;
// Debugging info goes over the top
CDebugViewRender : : Draw3DDebuggingInfo ( view ) ;
// Return to the previous view
SetupCurrentView ( vecOldOrigin , vecOldAngles , ( view_id_t ) iCurrentViewID ) ;
g_CurrentViewID = iCurrentViewID ; //just in case the cast to view_id_t screwed up the id #
}
void CViewRender : : Draw3dSkyboxworld_Portal ( const CViewSetup & view , int & nClearFlags , bool & bDrew3dSkybox , SkyboxVisibility_t & nSkyboxVisible , ITexture * pRenderTarget )
{
CRefPtr < CPortalSkyboxView > pSkyView = new CPortalSkyboxView ( this ) ;
if ( ( bDrew3dSkybox = pSkyView - > Setup ( view , & nClearFlags , & nSkyboxVisible , pRenderTarget ) ) = = true )
{
AddViewToScene ( pSkyView ) ;
}
}
# endif //PORTAL
//-----------------------------------------------------------------------------
// Methods related to controlling the cheap water distance
//-----------------------------------------------------------------------------
void CViewRender : : SetCheapWaterStartDistance ( float flCheapWaterStartDistance )
{
m_flCheapWaterStartDistance = flCheapWaterStartDistance ;
}
void CViewRender : : SetCheapWaterEndDistance ( float flCheapWaterEndDistance )
{
m_flCheapWaterEndDistance = flCheapWaterEndDistance ;
}
void CViewRender : : GetWaterLODParams ( float & flCheapWaterStartDistance , float & flCheapWaterEndDistance )
{
flCheapWaterStartDistance = m_flCheapWaterStartDistance ;
flCheapWaterEndDistance = m_flCheapWaterEndDistance ;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &view -
// &introData -
//-----------------------------------------------------------------------------
void CViewRender : : ViewDrawScene_Intro ( const CViewSetup & view , int nClearFlags , const IntroData_t & introData )
{
VPROF ( " CViewRender::ViewDrawScene " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
// this allows the refract texture to be updated once per *scene* on 360
// (e.g. once for a monitor scene and once for the main scene)
g_viewscene_refractUpdateFrame = gpGlobals - > framecount - 1 ;
// -----------------------------------------------------------------------
// Set the clear color to black since we are going to be adding up things
// in the frame buffer.
// -----------------------------------------------------------------------
// Clear alpha to 255 so that masking with the vortigaunts (0) works properly.
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
// -----------------------------------------------------------------------
// Draw the primary scene and copy it to the first framebuffer texture
// -----------------------------------------------------------------------
unsigned int visFlags ;
// NOTE: We only increment this once since time doesn't move forward.
ParticleMgr ( ) - > IncrementFrameCode ( ) ;
if ( introData . m_bDrawPrimary )
{
CViewSetup playerView ( view ) ;
playerView . origin = introData . m_vecCameraView ;
playerView . angles = introData . m_vecCameraViewAngles ;
if ( introData . m_playerViewFOV )
{
playerView . fov = ScaleFOVByWidthRatio ( introData . m_playerViewFOV , engine - > GetScreenAspectRatio ( ) / ( 4.0f / 3.0f ) ) ;
}
g_pClientShadowMgr - > PreRender ( ) ;
// Shadowed flashlights supported on ps_2_b and up...
if ( r_flashlightdepthtexture . GetBool ( ) )
{
g_pClientShadowMgr - > ComputeShadowDepthTextures ( playerView ) ;
}
SetupCurrentView ( playerView . origin , playerView . angles , VIEW_INTRO_PLAYER ) ;
// Invoke pre-render methods
IGameSystem : : PreRenderAllSystems ( ) ;
// Start view, clear frame/z buffer if necessary
SetupVis ( playerView , visFlags ) ;
render - > Push3DView ( playerView , VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH , NULL , GetFrustum ( ) ) ;
DrawWorldAndEntities ( true /* drawSkybox */ , playerView , VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH ) ;
render - > PopView ( GetFrustum ( ) ) ;
// Free shadow depth textures for use in future view
if ( r_flashlightdepthtexture . GetBool ( ) )
{
g_pClientShadowMgr - > UnlockAllShadowDepthTextures ( ) ;
}
}
else
{
pRenderContext - > ClearBuffers ( true , true ) ;
}
Rect_t actualRect ;
UpdateScreenEffectTexture ( 0 , view . x , view . y , view . width , view . height , false , & actualRect ) ;
g_pClientShadowMgr - > PreRender ( ) ;
// Shadowed flashlights supported on ps_2_b and up...
if ( r_flashlightdepthtexture . GetBool ( ) )
{
g_pClientShadowMgr - > ComputeShadowDepthTextures ( view ) ;
}
// -----------------------------------------------------------------------
// Draw the secondary scene and copy it to the second framebuffer texture
// -----------------------------------------------------------------------
SetupCurrentView ( view . origin , view . angles , VIEW_INTRO_CAMERA ) ;
// Invoke pre-render methods
IGameSystem : : PreRenderAllSystems ( ) ;
// Start view, clear frame/z buffer if necessary
SetupVis ( view , visFlags ) ;
// Clear alpha to 255 so that masking with the vortigaunts (0) works properly.
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
DrawWorldAndEntities ( true /* drawSkybox */ , view , VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH ) ;
UpdateScreenEffectTexture ( 1 , view . x , view . y , view . width , view . height ) ;
// -----------------------------------------------------------------------
// Draw quads on the screen for each screenspace pass.
// -----------------------------------------------------------------------
// Find the material that we use to render the overlays
IMaterial * pOverlayMaterial = materials - > FindMaterial ( " scripted/intro_screenspaceeffect " , TEXTURE_GROUP_OTHER ) ;
IMaterialVar * pModeVar = pOverlayMaterial - > FindVar ( " $mode " , NULL ) ;
IMaterialVar * pAlphaVar = pOverlayMaterial - > FindVar ( " $alpha " , NULL ) ;
pRenderContext - > ClearBuffers ( true , true ) ;
pRenderContext - > MatrixMode ( MATERIAL_VIEW ) ;
pRenderContext - > PushMatrix ( ) ;
pRenderContext - > LoadIdentity ( ) ;
pRenderContext - > MatrixMode ( MATERIAL_PROJECTION ) ;
pRenderContext - > PushMatrix ( ) ;
pRenderContext - > LoadIdentity ( ) ;
int passID ;
for ( passID = 0 ; passID < introData . m_Passes . Count ( ) ; passID + + )
{
const IntroDataBlendPass_t & pass = introData . m_Passes [ passID ] ;
if ( pass . m_Alpha = = 0 )
continue ;
// Pick one of the blend modes for the material.
if ( pass . m_BlendMode > = 0 & & pass . m_BlendMode < = 9 )
{
pModeVar - > SetIntValue ( pass . m_BlendMode ) ;
}
else
{
Assert ( 0 ) ;
}
// Set the alpha value for the material.
pAlphaVar - > SetFloatValue ( pass . m_Alpha ) ;
// Draw a quad for this pass.
ITexture * pTexture = GetFullFrameFrameBufferTexture ( 0 ) ;
pRenderContext - > DrawScreenSpaceRectangle ( pOverlayMaterial , 0 , 0 , view . width , view . height ,
actualRect . x , actualRect . y , actualRect . x + actualRect . width - 1 , actualRect . y + actualRect . height - 1 ,
pTexture - > GetActualWidth ( ) , pTexture - > GetActualHeight ( ) ) ;
}
pRenderContext - > MatrixMode ( MATERIAL_VIEW ) ;
pRenderContext - > PopMatrix ( ) ;
pRenderContext - > MatrixMode ( MATERIAL_PROJECTION ) ;
pRenderContext - > PopMatrix ( ) ;
// Draw the starfield
// FIXME
// blur?
// Disable fog for the rest of the stuff
DisableFog ( ) ;
// Here are the overlays...
CGlowOverlay : : DrawOverlays ( view . m_bCacheFullSceneState ) ;
// issue the pixel visibility tests
PixelVisibility_EndCurrentView ( ) ;
// And here are the screen-space effects
PerformScreenSpaceEffects ( 0 , 0 , view . width , view . height ) ;
// Make sure sound doesn't stutter
engine - > Sound_ExtraUpdate ( ) ;
// Debugging info goes over the top
CDebugViewRender : : Draw3DDebuggingInfo ( view ) ;
// Let the particle manager simulate things that haven't been simulated.
ParticleMgr ( ) - > PostRender ( ) ;
FinishCurrentView ( ) ;
// Free shadow depth textures for use in future view
if ( r_flashlightdepthtexture . GetBool ( ) )
{
g_pClientShadowMgr - > UnlockAllShadowDepthTextures ( ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets up scene and renders camera view
// Input : cameraNum -
// &cameraView
// *localPlayer -
// x -
// y -
// width -
// height -
// highend -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CViewRender : : DrawOneMonitor ( ITexture * pRenderTarget , int cameraNum , C_PointCamera * pCameraEnt ,
const CViewSetup & cameraView , C_BasePlayer * localPlayer , int x , int y , int width , int height )
{
# ifdef USE_MONITORS
VPROF_INCREMENT_COUNTER ( " cameras rendered " , 1 ) ;
// Setup fog state for the camera.
fogparams_t oldFogParams ;
float flOldZFar = 0.0f ;
bool fogEnabled = pCameraEnt - > IsFogEnabled ( ) ;
CViewSetup monitorView = cameraView ;
fogparams_t * pFogParams = NULL ;
if ( fogEnabled )
{
if ( ! localPlayer )
return false ;
pFogParams = localPlayer - > GetFogParams ( ) ;
// Save old fog data.
oldFogParams = * pFogParams ;
flOldZFar = cameraView . zFar ;
pFogParams - > enable = true ;
pFogParams - > start = pCameraEnt - > GetFogStart ( ) ;
pFogParams - > end = pCameraEnt - > GetFogEnd ( ) ;
pFogParams - > farz = pCameraEnt - > GetFogEnd ( ) ;
pFogParams - > maxdensity = pCameraEnt - > GetFogMaxDensity ( ) ;
unsigned char r , g , b ;
pCameraEnt - > GetFogColor ( r , g , b ) ;
pFogParams - > colorPrimary . SetR ( r ) ;
pFogParams - > colorPrimary . SetG ( g ) ;
pFogParams - > colorPrimary . SetB ( b ) ;
monitorView . zFar = pCameraEnt - > GetFogEnd ( ) ;
}
monitorView . width = width ;
monitorView . height = height ;
monitorView . x = x ;
monitorView . y = y ;
monitorView . origin = pCameraEnt - > GetAbsOrigin ( ) ;
monitorView . angles = pCameraEnt - > GetAbsAngles ( ) ;
monitorView . fov = pCameraEnt - > GetFOV ( ) ;
monitorView . m_bOrtho = false ;
monitorView . m_flAspectRatio = pCameraEnt - > UseScreenAspectRatio ( ) ? 0.0f : 1.0f ;
monitorView . m_bViewToProjectionOverride = false ;
// @MULTICORE (toml 8/11/2006): this should be a renderer....
Frustum frustum ;
render - > Push3DView ( monitorView , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR , pRenderTarget , ( VPlane * ) frustum ) ;
ViewDrawScene ( false , SKYBOX_2DSKYBOX_VISIBLE , monitorView , 0 , VIEW_MONITOR ) ;
render - > PopView ( frustum ) ;
// Reset the world fog parameters.
if ( fogEnabled )
{
if ( pFogParams )
{
* pFogParams = oldFogParams ;
}
monitorView . zFar = flOldZFar ;
}
# endif // USE_MONITORS
return true ;
}
void CViewRender : : DrawMonitors ( const CViewSetup & cameraView )
{
# ifdef PORTAL
g_pPortalRender - > DrawPortalsToTextures ( this , cameraView ) ;
# endif
# ifdef USE_MONITORS
// Early out if no cameras
C_PointCamera * pCameraEnt = GetPointCameraList ( ) ;
if ( ! pCameraEnt )
return ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
# ifdef _DEBUG
g_bRenderingCameraView = true ;
# endif
// FIXME: this should check for the ability to do a render target maybe instead.
// FIXME: shouldn't have to truck through all of the visible entities for this!!!!
ITexture * pCameraTarget = GetCameraTexture ( ) ;
int width = pCameraTarget - > GetActualWidth ( ) ;
int height = pCameraTarget - > GetActualHeight ( ) ;
C_BasePlayer * player = C_BasePlayer : : GetLocalPlayer ( ) ;
int cameraNum ;
for ( cameraNum = 0 ; pCameraEnt ! = NULL ; pCameraEnt = pCameraEnt - > m_pNext )
{
if ( ! pCameraEnt - > IsActive ( ) | | pCameraEnt - > IsDormant ( ) )
continue ;
if ( ! DrawOneMonitor ( pCameraTarget , cameraNum , pCameraEnt , cameraView , player , 0 , 0 , width , height ) )
continue ;
+ + cameraNum ;
}
if ( IsX360 ( ) & & cameraNum > 0 )
{
// resolve render target to system memory texture
// resolving *after* all monitors drawn to ensure a single blit using fastest resolve path
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > PushRenderTargetAndViewport ( pCameraTarget ) ;
pRenderContext - > CopyRenderTargetToTextureEx ( pCameraTarget , 0 , NULL , NULL ) ;
pRenderContext - > PopRenderTargetAndViewport ( ) ;
}
# ifdef _DEBUG
g_bRenderingCameraView = false ;
# endif
# endif // USE_MONITORS
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
ClientWorldListInfo_t * ClientWorldListInfo_t : : AllocPooled ( const ClientWorldListInfo_t & exemplar )
{
size_t nBytes = AlignValue ( ( exemplar . m_LeafCount * ( ( sizeof ( LeafIndex_t ) * 2 ) + sizeof ( LeafFogVolume_t ) ) ) , 4096 ) ;
ClientWorldListInfo_t * pResult = gm_Pool . GetObject ( ) ;
byte * pMemory = ( byte * ) pResult - > m_pLeafList ;
if ( pMemory )
{
// Previously allocated, add a reference. Otherwise comes out of GetObject as a new object with a refcount of 1
pResult - > AddRef ( ) ;
}
if ( ! pMemory | | _msize ( pMemory ) < nBytes )
{
pMemory = ( byte * ) realloc ( pMemory , nBytes ) ;
}
pResult - > m_pLeafList = ( LeafIndex_t * ) pMemory ;
pResult - > m_pLeafFogVolume = ( LeafFogVolume_t * ) ( pMemory + exemplar . m_LeafCount * sizeof ( LeafIndex_t ) ) ;
pResult - > m_pActualLeafIndex = ( LeafIndex_t * ) ( ( byte * ) ( pResult - > m_pLeafFogVolume ) + exemplar . m_LeafCount * sizeof ( LeafFogVolume_t ) ) ;
pResult - > m_bPooledAlloc = true ;
return pResult ;
}
bool ClientWorldListInfo_t : : OnFinalRelease ( )
{
if ( m_bPooledAlloc )
{
Assert ( m_pLeafList ) ;
gm_Pool . PutObject ( this ) ;
return false ;
}
return true ;
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CBase3dView : : CBase3dView ( CViewRender * pMainView ) :
m_pMainView ( pMainView ) ,
m_Frustum ( pMainView - > m_Frustum )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEnt -
// Output : int
//-----------------------------------------------------------------------------
VPlane * CBase3dView : : GetFrustum ( )
{
// The frustum is only valid while in a RenderView call.
// @MULTICORE (toml 8/11/2006): reimplement this when ready -- Assert(g_bRenderingView || g_bRenderingCameraView || g_bRenderingScreenshot);
return m_Frustum ;
}
CObjectPool < ClientWorldListInfo_t > ClientWorldListInfo_t : : gm_Pool ;
//-----------------------------------------------------------------------------
// Base class for 3d views
//-----------------------------------------------------------------------------
CRendering3dView : : CRendering3dView ( CViewRender * pMainView ) :
CBase3dView ( pMainView ) ,
m_pWorldRenderList ( NULL ) ,
m_pRenderablesList ( NULL ) ,
m_pWorldListInfo ( NULL ) ,
m_pCustomVisibility ( NULL ) ,
m_DrawFlags ( 0 ) ,
m_ClearFlags ( 0 )
{
}
//-----------------------------------------------------------------------------
// Sort entities in a back-to-front ordering
//-----------------------------------------------------------------------------
void CRendering3dView : : Setup ( const CViewSetup & setup )
{
// @MULTICORE (toml 8/15/2006): don't reset if parameters don't require it. For now, just reset
memcpy ( static_cast < CViewSetup * > ( this ) , & setup , sizeof ( setup ) ) ;
ReleaseLists ( ) ;
m_pRenderablesList = new CClientRenderablesList ;
m_pCustomVisibility = NULL ;
}
//-----------------------------------------------------------------------------
// Sort entities in a back-to-front ordering
//-----------------------------------------------------------------------------
void CRendering3dView : : ReleaseLists ( )
{
SafeRelease ( m_pWorldRenderList ) ;
SafeRelease ( m_pRenderablesList ) ;
SafeRelease ( m_pWorldListInfo ) ;
m_pCustomVisibility = NULL ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CRendering3dView : : SetupRenderablesList ( int viewID )
{
VPROF ( " CViewRender::SetupRenderablesList " ) ;
// Clear the list.
int i ;
for ( i = 0 ; i < RENDER_GROUP_COUNT ; i + + )
{
m_pRenderablesList - > m_RenderGroupCounts [ i ] = 0 ;
}
// Now collate the entities in the leaves.
if ( m_pMainView - > ShouldDrawEntities ( ) )
{
// Precache information used commonly in CollateRenderables
SetupRenderInfo_t setupInfo ;
setupInfo . m_pWorldListInfo = m_pWorldListInfo ;
setupInfo . m_nRenderFrame = m_pMainView - > BuildRenderablesListsNumber ( ) ; // only one incremented?
setupInfo . m_nDetailBuildFrame = m_pMainView - > BuildWorldListsNumber ( ) ; //
setupInfo . m_pRenderList = m_pRenderablesList ;
setupInfo . m_bDrawDetailObjects = g_pClientMode - > ShouldDrawDetailObjects ( ) & & r_DrawDetailProps . GetInt ( ) ;
setupInfo . m_bDrawTranslucentObjects = ( viewID ! = VIEW_SHADOW_DEPTH_TEXTURE ) ;
setupInfo . m_vecRenderOrigin = origin ;
setupInfo . m_vecRenderForward = CurrentViewForward ( ) ;
float fMaxDist = cl_maxrenderable_dist . GetFloat ( ) ;
// Shadowing light typically has a smaller farz than cl_maxrenderable_dist
setupInfo . m_flRenderDistSq = ( viewID = = VIEW_SHADOW_DEPTH_TEXTURE ) ? MIN ( zFar , fMaxDist ) : fMaxDist ;
setupInfo . m_flRenderDistSq * = setupInfo . m_flRenderDistSq ;
ClientLeafSystem ( ) - > BuildRenderablesList ( setupInfo ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose: Builds lists of things to render in the world, called once per view
//-----------------------------------------------------------------------------
void CRendering3dView : : UpdateRenderablesOpacity ( )
{
// Compute the prop opacity based on the view position and fov zoom scale
float flFactor = 1.0f ;
C_BasePlayer * pLocal = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( pLocal )
{
flFactor = pLocal - > GetFOVDistanceAdjustFactor ( ) ;
}
if ( cl_leveloverview . GetFloat ( ) > 0 )
{
// disable prop fading
flFactor = - 1 ;
}
// When zoomed in, tweak the opacity to stay visible from further away
staticpropmgr - > ComputePropOpacity ( origin , flFactor ) ;
// Build a list of detail props to render
DetailObjectSystem ( ) - > BuildDetailObjectRenderLists ( origin ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// Kinda awkward...three optional parameters at the end...
void CRendering3dView : : BuildWorldRenderLists ( bool bDrawEntities , int iForceViewLeaf /* = -1 */ ,
bool bUseCacheIfEnabled /* = true */ , bool bShadowDepth /* = false */ , float * pReflectionWaterHeight /*= NULL*/ )
{
VPROF_BUDGET ( " BuildWorldRenderLists " , VPROF_BUDGETGROUP_WORLD_RENDERING ) ;
// @MULTICORE (toml 8/18/2006): to address....
extern void UpdateClientRenderableInPVSStatus ( ) ;
UpdateClientRenderableInPVSStatus ( ) ;
Assert ( ! m_pWorldRenderList & & ! m_pWorldListInfo ) ;
m_pMainView - > IncWorldListsNumber ( ) ;
// Override vis data if specified this render, otherwise use default behavior with NULL
VisOverrideData_t * pVisData = ( m_pCustomVisibility & & m_pCustomVisibility - > m_VisData . m_fDistToAreaPortalTolerance ! = FLT_MAX ) ? & m_pCustomVisibility - > m_VisData : NULL ;
bool bUseCache = ( bUseCacheIfEnabled & & r_worldlistcache . GetBool ( ) ) ;
if ( ! bUseCache | | pVisData | | ! g_WorldListCache . Find ( * this , & m_pWorldRenderList , & m_pWorldListInfo ) )
{
// @MULTICORE (toml 8/18/2006): when make parallel, will have to change caching to be atomic, where follow ons receive a pointer to a list that is not yet built
m_pWorldRenderList = render - > CreateWorldList ( ) ;
m_pWorldListInfo = new ClientWorldListInfo_t ;
render - > BuildWorldLists ( m_pWorldRenderList , m_pWorldListInfo ,
( m_pCustomVisibility ) ? m_pCustomVisibility - > m_iForceViewLeaf : iForceViewLeaf ,
pVisData , bShadowDepth , pReflectionWaterHeight ) ;
if ( bUseCache & & ! pVisData )
{
g_WorldListCache . Add ( * this , m_pWorldRenderList , m_pWorldListInfo ) ;
}
}
if ( bDrawEntities )
{
UpdateRenderablesOpacity ( ) ;
}
}
//-----------------------------------------------------------------------------
// Purpose: Computes the actual world list info based on the render flags
//-----------------------------------------------------------------------------
void CRendering3dView : : PruneWorldListInfo ( )
{
// Drawing everything? Just return the world list info as-is
int nWaterDrawFlags = m_DrawFlags & ( DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER ) ;
if ( nWaterDrawFlags = = ( DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER ) )
{
return ;
}
ClientWorldListInfo_t * pNewInfo ;
// Only allocate memory if actually will draw something
if ( m_pWorldListInfo - > m_LeafCount > 0 & & nWaterDrawFlags )
{
pNewInfo = ClientWorldListInfo_t : : AllocPooled ( * m_pWorldListInfo ) ;
}
else
{
pNewInfo = new ClientWorldListInfo_t ;
}
pNewInfo - > m_ViewFogVolume = m_pWorldListInfo - > m_ViewFogVolume ;
pNewInfo - > m_LeafCount = 0 ;
// Not drawing anything? Then don't bother with renderable lists
if ( nWaterDrawFlags ! = 0 )
{
// Create a sub-list based on the actual leaves being rendered
bool bRenderingUnderwater = ( nWaterDrawFlags & DF_RENDER_UNDERWATER ) ! = 0 ;
for ( int i = 0 ; i < m_pWorldListInfo - > m_LeafCount ; + + i )
{
bool bLeafIsUnderwater = ( m_pWorldListInfo - > m_pLeafFogVolume [ i ] ! = - 1 ) ;
if ( bRenderingUnderwater = = bLeafIsUnderwater )
{
pNewInfo - > m_pLeafList [ pNewInfo - > m_LeafCount ] = m_pWorldListInfo - > m_pLeafList [ i ] ;
pNewInfo - > m_pLeafFogVolume [ pNewInfo - > m_LeafCount ] = m_pWorldListInfo - > m_pLeafFogVolume [ i ] ;
pNewInfo - > m_pActualLeafIndex [ pNewInfo - > m_LeafCount ] = i ;
+ + pNewInfo - > m_LeafCount ;
}
}
}
m_pWorldListInfo - > Release ( ) ;
m_pWorldListInfo = pNewInfo ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static inline void UpdateBrushModelLightmap ( IClientRenderable * pEnt )
{
model_t * pModel = ( model_t * ) pEnt - > GetModel ( ) ;
render - > UpdateBrushModelLightmap ( pModel , pEnt ) ;
}
void CRendering3dView : : BuildRenderableRenderLists ( int viewID )
{
MDLCACHE_CRITICAL_SECTION ( ) ;
if ( viewID ! = VIEW_SHADOW_DEPTH_TEXTURE )
{
render - > BeginUpdateLightmaps ( ) ;
}
m_pMainView - > IncRenderablesListsNumber ( ) ;
ClientWorldListInfo_t & info = * m_pWorldListInfo ;
// For better sorting, find out the leaf *nearest* to the camera
// and render translucent objects as if they are in that leaf.
if ( m_pMainView - > ShouldDrawEntities ( ) & & ( viewID ! = VIEW_SHADOW_DEPTH_TEXTURE ) )
{
ClientLeafSystem ( ) - > ComputeTranslucentRenderLeaf (
info . m_LeafCount , info . m_pLeafList , info . m_pLeafFogVolume , m_pMainView - > BuildRenderablesListsNumber ( ) , viewID ) ;
}
SetupRenderablesList ( viewID ) ;
if ( viewID = = VIEW_MAIN )
{
StudioStats_FindClosestEntity ( m_pRenderablesList ) ;
}
if ( viewID ! = VIEW_SHADOW_DEPTH_TEXTURE )
{
// update lightmap on brush models if necessary
CClientRenderablesList : : CEntry * pEntities = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_BRUSH ] ;
int nOpaque = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_BRUSH ] ;
int i ;
for ( i = 0 ; i < nOpaque ; + + i )
{
Assert ( pEntities [ i ] . m_TwoPass = = 0 ) ;
UpdateBrushModelLightmap ( pEntities [ i ] . m_pRenderable ) ;
}
// update lightmap on brush models if necessary
pEntities = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_TRANSLUCENT_ENTITY ] ;
int nTranslucent = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_TRANSLUCENT_ENTITY ] ;
for ( i = 0 ; i < nTranslucent ; + + i )
{
const model_t * pModel = pEntities [ i ] . m_pRenderable - > GetModel ( ) ;
if ( pModel )
{
int nModelType = modelinfo - > GetModelType ( pModel ) ;
if ( nModelType = = mod_brush )
{
UpdateBrushModelLightmap ( pEntities [ i ] . m_pRenderable ) ;
}
}
}
render - > EndUpdateLightmaps ( ) ;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CRendering3dView : : DrawWorld ( float waterZAdjust )
{
VPROF_INCREMENT_COUNTER ( " RenderWorld " , 1 ) ;
VPROF_BUDGET ( " DrawWorld " , VPROF_BUDGETGROUP_WORLD_RENDERING ) ;
if ( ! r_drawopaqueworld . GetBool ( ) )
{
return ;
}
unsigned long engineFlags = BuildEngineDrawWorldListFlags ( m_DrawFlags ) ;
render - > DrawWorldLists ( m_pWorldRenderList , engineFlags , waterZAdjust ) ;
}
CMaterialReference g_material_WriteZ ; //init'ed on by CViewRender::Init()
//-----------------------------------------------------------------------------
// Fakes per-entity clip planes on cards that don't support user clip planes.
// Achieves the effect by drawing an invisible box that writes to the depth buffer
// around the clipped area. It's not perfect, but better than nothing.
//-----------------------------------------------------------------------------
static void DrawClippedDepthBox ( IClientRenderable * pEnt , float * pClipPlane )
{
//#define DEBUG_DRAWCLIPPEDDEPTHBOX //uncomment to draw the depth box as a colorful box
static const int iQuads [ 6 ] [ 5 ] = { { 0 , 4 , 6 , 2 , 0 } , //always an extra copy of first index at end to make some algorithms simpler
{ 3 , 7 , 5 , 1 , 3 } ,
{ 1 , 5 , 4 , 0 , 1 } ,
{ 2 , 6 , 7 , 3 , 2 } ,
{ 0 , 2 , 3 , 1 , 0 } ,
{ 5 , 7 , 6 , 4 , 5 } } ;
static const int iLines [ 12 ] [ 2 ] = { { 0 , 1 } ,
{ 0 , 2 } ,
{ 0 , 4 } ,
{ 1 , 3 } ,
{ 1 , 5 } ,
{ 2 , 3 } ,
{ 2 , 6 } ,
{ 3 , 7 } ,
{ 4 , 6 } ,
{ 4 , 5 } ,
{ 5 , 7 } ,
{ 6 , 7 } } ;
# ifdef DEBUG_DRAWCLIPPEDDEPTHBOX
static const float fColors [ 6 ] [ 3 ] = { { 1.0f , 0.0f , 0.0f } ,
{ 0.0f , 1.0f , 1.0f } ,
{ 0.0f , 1.0f , 0.0f } ,
{ 1.0f , 0.0f , 1.0f } ,
{ 0.0f , 0.0f , 1.0f } ,
{ 1.0f , 1.0f , 0.0f } } ;
# endif
Vector vNormal = * ( Vector * ) pClipPlane ;
float fPlaneDist = pClipPlane [ 3 ] ;
Vector vMins , vMaxs ;
pEnt - > GetRenderBounds ( vMins , vMaxs ) ;
Vector vOrigin = pEnt - > GetRenderOrigin ( ) ;
QAngle qAngles = pEnt - > GetRenderAngles ( ) ;
Vector vForward , vUp , vRight ;
AngleVectors ( qAngles , & vForward , & vRight , & vUp ) ;
Vector vPoints [ 8 ] ;
vPoints [ 0 ] = vOrigin + ( vForward * vMins . x ) + ( vRight * vMins . y ) + ( vUp * vMins . z ) ;
vPoints [ 1 ] = vOrigin + ( vForward * vMaxs . x ) + ( vRight * vMins . y ) + ( vUp * vMins . z ) ;
vPoints [ 2 ] = vOrigin + ( vForward * vMins . x ) + ( vRight * vMaxs . y ) + ( vUp * vMins . z ) ;
vPoints [ 3 ] = vOrigin + ( vForward * vMaxs . x ) + ( vRight * vMaxs . y ) + ( vUp * vMins . z ) ;
vPoints [ 4 ] = vOrigin + ( vForward * vMins . x ) + ( vRight * vMins . y ) + ( vUp * vMaxs . z ) ;
vPoints [ 5 ] = vOrigin + ( vForward * vMaxs . x ) + ( vRight * vMins . y ) + ( vUp * vMaxs . z ) ;
vPoints [ 6 ] = vOrigin + ( vForward * vMins . x ) + ( vRight * vMaxs . y ) + ( vUp * vMaxs . z ) ;
vPoints [ 7 ] = vOrigin + ( vForward * vMaxs . x ) + ( vRight * vMaxs . y ) + ( vUp * vMaxs . z ) ;
int iClipped [ 8 ] ;
float fDists [ 8 ] ;
for ( int i = 0 ; i ! = 8 ; + + i )
{
fDists [ i ] = vPoints [ i ] . Dot ( vNormal ) - fPlaneDist ;
iClipped [ i ] = ( fDists [ i ] > 0.0f ) ? 1 : 0 ;
}
Vector vSplitPoints [ 8 ] [ 8 ] ; //obviously there are only 12 lines, not 64 lines or 64 split points, but the indexing is way easier like this
int iLineStates [ 8 ] [ 8 ] ; //0 = unclipped, 2 = wholly clipped, 3 = first point clipped, 4 = second point clipped
//categorize lines and generate split points where needed
for ( int i = 0 ; i ! = 12 ; + + i )
{
const int * pPoints = iLines [ i ] ;
int iLineState = ( iClipped [ pPoints [ 0 ] ] + iClipped [ pPoints [ 1 ] ] ) ;
if ( iLineState ! = 1 ) //either both points are clipped, or neither are clipped
{
iLineStates [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] =
iLineStates [ pPoints [ 1 ] ] [ pPoints [ 0 ] ] =
iLineState ;
}
else
{
//one point is clipped, the other is not
if ( iClipped [ pPoints [ 0 ] ] = = 1 )
{
//first point was clipped, index 1 has the negative distance
float fInvTotalDist = 1.0f / ( fDists [ pPoints [ 0 ] ] - fDists [ pPoints [ 1 ] ] ) ;
vSplitPoints [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] =
vSplitPoints [ pPoints [ 1 ] ] [ pPoints [ 0 ] ] =
( vPoints [ pPoints [ 1 ] ] * ( fDists [ pPoints [ 0 ] ] * fInvTotalDist ) ) - ( vPoints [ pPoints [ 0 ] ] * ( fDists [ pPoints [ 1 ] ] * fInvTotalDist ) ) ;
Assert ( fabs ( vNormal . Dot ( vSplitPoints [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] ) - fPlaneDist ) < 0.01f ) ;
iLineStates [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] = 3 ;
iLineStates [ pPoints [ 1 ] ] [ pPoints [ 0 ] ] = 4 ;
}
else
{
//second point was clipped, index 0 has the negative distance
float fInvTotalDist = 1.0f / ( fDists [ pPoints [ 1 ] ] - fDists [ pPoints [ 0 ] ] ) ;
vSplitPoints [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] =
vSplitPoints [ pPoints [ 1 ] ] [ pPoints [ 0 ] ] =
( vPoints [ pPoints [ 0 ] ] * ( fDists [ pPoints [ 1 ] ] * fInvTotalDist ) ) - ( vPoints [ pPoints [ 1 ] ] * ( fDists [ pPoints [ 0 ] ] * fInvTotalDist ) ) ;
Assert ( fabs ( vNormal . Dot ( vSplitPoints [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] ) - fPlaneDist ) < 0.01f ) ;
iLineStates [ pPoints [ 0 ] ] [ pPoints [ 1 ] ] = 4 ;
iLineStates [ pPoints [ 1 ] ] [ pPoints [ 0 ] ] = 3 ;
}
}
}
CMatRenderContextPtr pRenderContext ( materials ) ;
# ifdef DEBUG_DRAWCLIPPEDDEPTHBOX
pRenderContext - > Bind ( materials - > FindMaterial ( " debug/debugvertexcolor " , TEXTURE_GROUP_OTHER ) , NULL ) ;
# else
pRenderContext - > Bind ( g_material_WriteZ , NULL ) ;
# endif
CMeshBuilder meshBuilder ;
IMesh * pMesh = pRenderContext - > GetDynamicMesh ( false ) ;
meshBuilder . Begin ( pMesh , MATERIAL_TRIANGLES , 18 ) ; //6 sides, possible one cut per side. Any side is capable of having 3 tri's. Lots of padding for things that aren't possible
//going to draw as a collection of triangles, arranged as a triangle fan on each side
for ( int i = 0 ; i ! = 6 ; + + i )
{
const int * pPoints = iQuads [ i ] ;
//can't start the fan on a wholly clipped line, so seek to one that isn't
int j = 0 ;
do
{
if ( iLineStates [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] ! = 2 ) //at least part of this line will be drawn
break ;
+ + j ;
} while ( j ! = 3 ) ;
if ( j = = 3 ) //not enough lines to even form a triangle
continue ;
float * pStartPoint = 0 ;
float * pTriangleFanPoints [ 4 ] ; //at most, one of our fans will have 5 points total, with the first point being stored separately as pStartPoint
int iTriangleFanPointCount = 1 ; //the switch below creates the first for sure
//figure out how to start the fan
switch ( iLineStates [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] )
{
case 0 : //uncut
pStartPoint = & vPoints [ pPoints [ j ] ] . x ;
pTriangleFanPoints [ 0 ] = & vPoints [ pPoints [ j + 1 ] ] . x ;
break ;
case 4 : //second index was clipped
pStartPoint = & vPoints [ pPoints [ j ] ] . x ;
pTriangleFanPoints [ 0 ] = & vSplitPoints [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] . x ;
break ;
case 3 : //first index was clipped
pStartPoint = & vSplitPoints [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] . x ;
pTriangleFanPoints [ 0 ] = & vPoints [ pPoints [ j + 1 ] ] . x ;
break ;
default :
Assert ( false ) ;
break ;
} ;
for ( + + j ; j ! = 3 ; + + j ) //add end points for the rest of the indices, we're assembling a triangle fan
{
switch ( iLineStates [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] )
{
case 0 : //uncut line, normal endpoint
pTriangleFanPoints [ iTriangleFanPointCount ] = & vPoints [ pPoints [ j + 1 ] ] . x ;
+ + iTriangleFanPointCount ;
break ;
case 2 : //wholly cut line, no endpoint
break ;
case 3 : //first point is clipped, normal endpoint
//special case, adds start and end point
pTriangleFanPoints [ iTriangleFanPointCount ] = & vSplitPoints [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] . x ;
+ + iTriangleFanPointCount ;
pTriangleFanPoints [ iTriangleFanPointCount ] = & vPoints [ pPoints [ j + 1 ] ] . x ;
+ + iTriangleFanPointCount ;
break ;
case 4 : //second point is clipped
pTriangleFanPoints [ iTriangleFanPointCount ] = & vSplitPoints [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] . x ;
+ + iTriangleFanPointCount ;
break ;
default :
Assert ( false ) ;
break ;
} ;
}
//special case endpoints, half-clipped lines have a connecting line between them and the next line (first line in this case)
switch ( iLineStates [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] )
{
case 3 :
case 4 :
pTriangleFanPoints [ iTriangleFanPointCount ] = & vSplitPoints [ pPoints [ j ] ] [ pPoints [ j + 1 ] ] . x ;
+ + iTriangleFanPointCount ;
break ;
} ;
Assert ( iTriangleFanPointCount < = 4 ) ;
//add the fan to the mesh
int iLoopStop = iTriangleFanPointCount - 1 ;
for ( int k = 0 ; k ! = iLoopStop ; + + k )
{
meshBuilder . Position3fv ( pStartPoint ) ;
# ifdef DEBUG_DRAWCLIPPEDDEPTHBOX
float fHalfColors [ 3 ] = { fColors [ i ] [ 0 ] * 0.5f , fColors [ i ] [ 1 ] * 0.5f , fColors [ i ] [ 2 ] * 0.5f } ;
meshBuilder . Color3fv ( fHalfColors ) ;
# endif
meshBuilder . AdvanceVertex ( ) ;
meshBuilder . Position3fv ( pTriangleFanPoints [ k ] ) ;
# ifdef DEBUG_DRAWCLIPPEDDEPTHBOX
meshBuilder . Color3fv ( fColors [ i ] ) ;
# endif
meshBuilder . AdvanceVertex ( ) ;
meshBuilder . Position3fv ( pTriangleFanPoints [ k + 1 ] ) ;
# ifdef DEBUG_DRAWCLIPPEDDEPTHBOX
meshBuilder . Color3fv ( fColors [ i ] ) ;
# endif
meshBuilder . AdvanceVertex ( ) ;
}
}
meshBuilder . End ( ) ;
pMesh - > Draw ( ) ;
pRenderContext - > Flush ( false ) ;
}
//-----------------------------------------------------------------------------
// Draws all opaque renderables in leaves that were rendered
//-----------------------------------------------------------------------------
static inline void DrawOpaqueRenderable ( IClientRenderable * pEnt , bool bTwoPass , ERenderDepthMode DepthMode , int nDefaultFlags = 0 )
{
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
float color [ 3 ] ;
pEnt - > GetColorModulation ( color ) ;
render - > SetColorModulation ( color ) ;
int flags = nDefaultFlags | STUDIO_RENDER ;
if ( bTwoPass )
{
flags | = STUDIO_TWOPASS ;
}
if ( DepthMode = = DEPTH_MODE_SHADOW )
{
flags | = STUDIO_SHADOWDEPTHTEXTURE ;
}
else if ( DepthMode = = DEPTH_MODE_SSA0 )
{
flags | = STUDIO_SSAODEPTHTEXTURE ;
}
float * pRenderClipPlane = NULL ;
if ( r_entityclips . GetBool ( ) )
pRenderClipPlane = pEnt - > GetRenderClipPlane ( ) ;
if ( pRenderClipPlane )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
if ( ! materials - > UsingFastClipping ( ) ) //do NOT change the fast clip plane mid-scene, depth problems result. Regular user clip planes are fine though
pRenderContext - > PushCustomClipPlane ( pRenderClipPlane ) ;
else
DrawClippedDepthBox ( pEnt , pRenderClipPlane ) ;
Assert ( view - > GetCurrentlyDrawingEntity ( ) = = NULL ) ;
view - > SetCurrentlyDrawingEntity ( pEnt - > GetIClientUnknown ( ) - > GetBaseEntity ( ) ) ;
pEnt - > DrawModel ( flags ) ;
view - > SetCurrentlyDrawingEntity ( NULL ) ;
if ( pRenderClipPlane & & ! materials - > UsingFastClipping ( ) )
pRenderContext - > PopCustomClipPlane ( ) ;
}
else
{
Assert ( view - > GetCurrentlyDrawingEntity ( ) = = NULL ) ;
view - > SetCurrentlyDrawingEntity ( pEnt - > GetIClientUnknown ( ) - > GetBaseEntity ( ) ) ;
pEnt - > DrawModel ( flags ) ;
view - > SetCurrentlyDrawingEntity ( NULL ) ;
}
}
//-------------------------------------
ConVar r_drawopaquestaticpropslast ( " r_drawopaquestaticpropslast " , " 0 " , 0 , " Whether opaque static props are rendered after non-npcs " ) ;
# define DEBUG_BUCKETS 0
# if DEBUG_BUCKETS
ConVar r_drawopaque_old ( " r_drawopaque_old " , " 0 " , 0 , " Whether old unbucketed technique is used " ) ;
ConVar r_drawopaquesbucket ( " r_drawopaquesbucket " , " 0 " , FCVAR_CHEAT , " Draw only specific bucket: positive - props, negative - ents " ) ;
ConVar r_drawopaquesbucket_stats ( " r_drawopaquesbucket_stats " , " 0 " , FCVAR_CHEAT , " Draw distribution of props/ents in the buckets " ) ;
# endif
static void SetupBonesOnBaseAnimating ( C_BaseAnimating * & pBaseAnimating )
{
pBaseAnimating - > SetupBones ( NULL , - 1 , - 1 , gpGlobals - > curtime ) ;
}
static void DrawOpaqueRenderables_DrawBrushModels ( CClientRenderablesList : : CEntry * pEntitiesBegin , CClientRenderablesList : : CEntry * pEntitiesEnd , ERenderDepthMode DepthMode )
{
for ( CClientRenderablesList : : CEntry * itEntity = pEntitiesBegin ; itEntity < pEntitiesEnd ; + + itEntity )
{
Assert ( ! itEntity - > m_TwoPass ) ;
DrawOpaqueRenderable ( itEntity - > m_pRenderable , false , DepthMode ) ;
}
}
static void DrawOpaqueRenderables_DrawStaticProps ( CClientRenderablesList : : CEntry * pEntitiesBegin , CClientRenderablesList : : CEntry * pEntitiesEnd , ERenderDepthMode DepthMode )
{
if ( pEntitiesEnd = = pEntitiesBegin )
return ;
float one [ 4 ] = { 1.0f , 1.0f , 1.0f , 1.0f } ;
render - > SetColorModulation ( one ) ;
render - > SetBlend ( 1.0f ) ;
const int MAX_STATICS_PER_BATCH = 512 ;
IClientRenderable * pStatics [ MAX_STATICS_PER_BATCH ] ;
int numScheduled = 0 , numAvailable = MAX_STATICS_PER_BATCH ;
for ( CClientRenderablesList : : CEntry * itEntity = pEntitiesBegin ; itEntity < pEntitiesEnd ; + + itEntity )
{
if ( itEntity - > m_pRenderable )
/**/ ;
else
continue ;
if ( g_pStudioStatsEntity ! = NULL & & g_CurrentViewID = = VIEW_MAIN & & itEntity - > m_pRenderable = = g_pStudioStatsEntity )
{
DrawOpaqueRenderable ( itEntity - > m_pRenderable , false , DepthMode , STUDIO_GENERATE_STATS ) ;
continue ;
}
pStatics [ numScheduled + + ] = itEntity - > m_pRenderable ;
if ( - - numAvailable > 0 )
continue ; // place a hint for compiler to predict more common case in the loop
staticpropmgr - > DrawStaticProps ( pStatics , numScheduled , DepthMode , vcollide_wireframe . GetBool ( ) ) ;
numScheduled = 0 ;
numAvailable = MAX_STATICS_PER_BATCH ;
}
if ( numScheduled )
staticpropmgr - > DrawStaticProps ( pStatics , numScheduled , DepthMode , vcollide_wireframe . GetBool ( ) ) ;
}
static void DrawOpaqueRenderables_Range ( CClientRenderablesList : : CEntry * pEntitiesBegin , CClientRenderablesList : : CEntry * pEntitiesEnd , ERenderDepthMode DepthMode )
{
for ( CClientRenderablesList : : CEntry * itEntity = pEntitiesBegin ; itEntity < pEntitiesEnd ; + + itEntity )
{
if ( itEntity - > m_pRenderable )
DrawOpaqueRenderable ( itEntity - > m_pRenderable , ( itEntity - > m_TwoPass ! = 0 ) , DepthMode ) ;
}
}
void CRendering3dView : : DrawOpaqueRenderables ( ERenderDepthMode DepthMode )
{
VPROF_BUDGET ( " CViewRender::DrawOpaqueRenderables " , " DrawOpaqueRenderables " ) ;
if ( ! r_drawopaquerenderables . GetBool ( ) )
return ;
if ( ! m_pMainView - > ShouldDrawEntities ( ) )
return ;
render - > SetBlend ( 1 ) ;
//
// Prepare to iterate over all leaves that were visible, and draw opaque things in them.
//
RopeManager ( ) - > ResetRenderCache ( ) ;
g_pParticleSystemMgr - > ResetRenderCache ( ) ;
//bool const bDrawopaquestaticpropslast = r_drawopaquestaticpropslast.GetBool();
//
// First do the brush models
//
{
CClientRenderablesList : : CEntry * pEntitiesBegin , * pEntitiesEnd ;
pEntitiesBegin = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_BRUSH ] ;
pEntitiesEnd = pEntitiesBegin + m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_BRUSH ] ;
DrawOpaqueRenderables_DrawBrushModels ( pEntitiesBegin , pEntitiesEnd , DepthMode ) ;
}
# if DEBUG_BUCKETS
{
con_nprint_s nxPrn = { 0 } ;
nxPrn . index = 16 ;
nxPrn . time_to_live = - 1 ;
nxPrn . color [ 0 ] = 0.9f , nxPrn . color [ 1 ] = 1.0f , nxPrn . color [ 2 ] = 0.9f ;
nxPrn . fixed_width_font = true ;
engine - > Con_NXPrintf ( & nxPrn , " Draw Opaque Technique : NEW " ) ;
if ( r_drawopaque_old . GetBool ( ) )
{
engine - > Con_NXPrintf ( & nxPrn , " Draw Opaque Technique : OLD " ) ;
// now the static props
{
for ( int bucket = RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS - 1 ; bucket - - > 0 ; )
{
CClientRenderablesList : : CEntry
* const pEntitiesBegin = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_STATIC_HUGE + 2 * bucket ] ,
* const pEntitiesEnd = pEntitiesBegin + m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_STATIC_HUGE + 2 * bucket ] ;
DrawOpaqueRenderables_DrawStaticProps ( pEntitiesBegin , pEntitiesEnd , bShadowDepth ) ;
}
}
// now the other opaque entities
for ( int bucket = RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS - 1 ; bucket - - > 0 ; )
{
CClientRenderablesList : : CEntry
* const pEntitiesBegin = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ,
* const pEntitiesEnd = pEntitiesBegin + m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ;
DrawOpaqueRenderables_Range ( pEntitiesBegin , pEntitiesEnd , bShadowDepth ) ;
}
//
// Ropes and particles
//
RopeManager ( ) - > DrawRenderCache ( bShadowDepth ) ;
g_pParticleSystemMgr - > DrawRenderCache ( bShadowDepth ) ;
return ;
}
}
# endif
//
// Sort everything that's not a static prop
//
int numOpaqueEnts = 0 ;
for ( int bucket = 0 ; bucket < RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS ; + + bucket )
numOpaqueEnts + = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ;
CUtlVector < C_BaseAnimating * > arrBoneSetupNpcsLast ( ( C_BaseAnimating * * ) _alloca ( numOpaqueEnts * sizeof ( C_BaseAnimating * ) ) , numOpaqueEnts , numOpaqueEnts ) ;
CUtlVector < CClientRenderablesList : : CEntry > arrRenderEntsNpcsFirst ( ( CClientRenderablesList : : CEntry * ) _alloca ( numOpaqueEnts * sizeof ( CClientRenderablesList : : CEntry ) ) , numOpaqueEnts , numOpaqueEnts ) ;
int numNpcs = 0 , numNonNpcsAnimating = 0 ;
for ( int bucket = 0 ; bucket < RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS ; + + bucket )
{
for ( CClientRenderablesList : : CEntry
* const pEntitiesBegin = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ,
* const pEntitiesEnd = pEntitiesBegin + m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ,
* itEntity = pEntitiesBegin ; itEntity < pEntitiesEnd ; + + itEntity )
{
C_BaseEntity * pEntity = itEntity - > m_pRenderable ? itEntity - > m_pRenderable - > GetIClientUnknown ( ) - > GetBaseEntity ( ) : NULL ;
if ( pEntity )
{
if ( pEntity - > IsNPC ( ) )
{
C_BaseAnimating * pba = assert_cast < C_BaseAnimating * > ( pEntity ) ;
arrRenderEntsNpcsFirst [ numNpcs + + ] = * itEntity ;
arrBoneSetupNpcsLast [ numOpaqueEnts - numNpcs ] = pba ;
itEntity - > m_pRenderable = NULL ; // We will render NPCs separately
itEntity - > m_RenderHandle = NULL ;
continue ;
}
else if ( pEntity - > GetBaseAnimating ( ) )
{
C_BaseAnimating * pba = assert_cast < C_BaseAnimating * > ( pEntity ) ;
arrBoneSetupNpcsLast [ numNonNpcsAnimating + + ] = pba ;
// fall through
}
}
}
}
if ( 0 & & r_threaded_renderables . GetBool ( ) )
{
ParallelProcess ( " BoneSetupNpcsLast " , arrBoneSetupNpcsLast . Base ( ) + numOpaqueEnts - numNpcs , numNpcs , & SetupBonesOnBaseAnimating ) ;
ParallelProcess ( " BoneSetupNpcsLast NonNPCs " , arrBoneSetupNpcsLast . Base ( ) , numNonNpcsAnimating , & SetupBonesOnBaseAnimating ) ;
}
//
// Draw static props + opaque entities from the biggest bucket to the smallest
//
{
CClientRenderablesList : : CEntry * pEnts [ RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS ] [ 2 ] ;
CClientRenderablesList : : CEntry * pProps [ RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS ] [ 2 ] ;
for ( int bucket = 0 ; bucket < RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS ; + + bucket )
{
pEnts [ bucket ] [ 0 ] = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ;
pEnts [ bucket ] [ 1 ] = pEnts [ bucket ] [ 0 ] + m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_ENTITY_HUGE + 2 * bucket ] ;
pProps [ bucket ] [ 0 ] = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_OPAQUE_STATIC_HUGE + 2 * bucket ] ;
pProps [ bucket ] [ 1 ] = pProps [ bucket ] [ 0 ] + m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_OPAQUE_STATIC_HUGE + 2 * bucket ] ;
// Render sequence debugging
# if DEBUG_BUCKETS
if ( r_drawopaquesbucket_stats . GetBool ( ) )
{
con_nprint_s nxPrn = { 0 } ;
nxPrn . index = 20 + bucket * 3 ;
nxPrn . time_to_live = - 1 ;
nxPrn . color [ 0 ] = 0.9f , nxPrn . color [ 1 ] = 1.0f , nxPrn . color [ 2 ] = 0.9f ;
nxPrn . fixed_width_font = true ;
if ( bDrawopaquestaticpropslast )
engine - > Con_NXPrintf ( & nxPrn , " [ %2d ] Ents : %3d " , bucket + 1 , pEnts [ bucket ] [ 1 ] - pEnts [ bucket ] [ 0 ] ) ,
+ + nxPrn . index ,
engine - > Con_NXPrintf ( & nxPrn , " [ %2d ] Props: %3d " , bucket + 1 , pProps [ bucket ] [ 1 ] - pProps [ bucket ] [ 0 ] ) ;
else
engine - > Con_NXPrintf ( & nxPrn , " [ %2d ] Props: %3d " , bucket + 1 , pProps [ bucket ] [ 1 ] - pProps [ bucket ] [ 0 ] ) ,
+ + nxPrn . index ,
engine - > Con_NXPrintf ( & nxPrn , " [ %2d ] Ents : %3d " , bucket + 1 , pEnts [ bucket ] [ 1 ] - pEnts [ bucket ] [ 0 ] ) ;
}
# endif
}
# if DEBUG_BUCKETS
if ( int iBucket = r_drawopaquesbucket . GetInt ( ) )
{
if ( iBucket > 0 & & iBucket < = RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS )
{
DrawOpaqueRenderables_Range ( pEnts [ iBucket - 1 ] [ 0 ] , pEnts [ iBucket - 1 ] [ 1 ] , bShadowDepth ) ;
}
if ( iBucket < 0 & & iBucket > = - RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS )
{
DrawOpaqueRenderables_DrawStaticProps ( pProps [ - 1 - iBucket ] [ 0 ] , pProps [ - 1 - iBucket ] [ 1 ] , bShadowDepth ) ;
}
}
else
# endif
for ( int bucket = 0 ; bucket < RENDER_GROUP_CFG_NUM_OPAQUE_ENT_BUCKETS ; + + bucket )
{
// PVS-Studio pointed out that the two sides of the if/else were identical. Fixing
// this long-broken behavior would change rendering, so I fixed the code but
// commented out the new behavior. Uncomment the if statement and else block
// when needed.
//if ( bDrawopaquestaticpropslast )
{
DrawOpaqueRenderables_Range ( pEnts [ bucket ] [ 0 ] , pEnts [ bucket ] [ 1 ] , DepthMode ) ;
DrawOpaqueRenderables_DrawStaticProps ( pProps [ bucket ] [ 0 ] , pProps [ bucket ] [ 1 ] , DepthMode ) ;
}
/*else
{
DrawOpaqueRenderables_DrawStaticProps ( pProps [ bucket ] [ 0 ] , pProps [ bucket ] [ 1 ] , DepthMode ) ;
DrawOpaqueRenderables_Range ( pEnts [ bucket ] [ 0 ] , pEnts [ bucket ] [ 1 ] , DepthMode ) ;
} */
}
}
//
// Draw NPCs now
//
DrawOpaqueRenderables_Range ( arrRenderEntsNpcsFirst . Base ( ) , arrRenderEntsNpcsFirst . Base ( ) + numNpcs , DepthMode ) ;
//
// Ropes and particles
//
RopeManager ( ) - > DrawRenderCache ( DepthMode ) ;
g_pParticleSystemMgr - > DrawRenderCache ( DepthMode ) ;
}
//-----------------------------------------------------------------------------
// Renders all translucent world + detail objects in a particular set of leaves
//-----------------------------------------------------------------------------
void CRendering3dView : : DrawTranslucentWorldInLeaves ( bool bShadowDepth )
{
VPROF_BUDGET ( " CViewRender::DrawTranslucentWorldInLeaves " , VPROF_BUDGETGROUP_WORLD_RENDERING ) ;
const ClientWorldListInfo_t & info = * m_pWorldListInfo ;
for ( int iCurLeafIndex = info . m_LeafCount - 1 ; iCurLeafIndex > = 0 ; iCurLeafIndex - - )
{
int nActualLeafIndex = info . m_pActualLeafIndex ? info . m_pActualLeafIndex [ iCurLeafIndex ] : iCurLeafIndex ;
Assert ( nActualLeafIndex ! = INVALID_LEAF_INDEX ) ;
if ( render - > LeafContainsTranslucentSurfaces ( m_pWorldRenderList , nActualLeafIndex , m_DrawFlags ) )
{
// Now draw the surfaces in this leaf
render - > DrawTranslucentSurfaces ( m_pWorldRenderList , nActualLeafIndex , m_DrawFlags , bShadowDepth ) ;
}
}
}
//-----------------------------------------------------------------------------
// Renders all translucent world + detail objects in a particular set of leaves
//-----------------------------------------------------------------------------
void CRendering3dView : : DrawTranslucentWorldAndDetailPropsInLeaves ( int iCurLeafIndex , int iFinalLeafIndex , int nEngineDrawFlags , int & nDetailLeafCount , LeafIndex_t * pDetailLeafList , bool bShadowDepth )
{
VPROF_BUDGET ( " CViewRender::DrawTranslucentWorldAndDetailPropsInLeaves " , VPROF_BUDGETGROUP_WORLD_RENDERING ) ;
const ClientWorldListInfo_t & info = * m_pWorldListInfo ;
for ( ; iCurLeafIndex > = iFinalLeafIndex ; iCurLeafIndex - - )
{
int nActualLeafIndex = info . m_pActualLeafIndex ? info . m_pActualLeafIndex [ iCurLeafIndex ] : iCurLeafIndex ;
Assert ( nActualLeafIndex ! = INVALID_LEAF_INDEX ) ;
if ( render - > LeafContainsTranslucentSurfaces ( m_pWorldRenderList , nActualLeafIndex , nEngineDrawFlags ) )
{
// First draw any queued-up detail props from previously visited leaves
DetailObjectSystem ( ) - > RenderTranslucentDetailObjects ( CurrentViewOrigin ( ) , CurrentViewForward ( ) , CurrentViewRight ( ) , CurrentViewUp ( ) , nDetailLeafCount , pDetailLeafList ) ;
nDetailLeafCount = 0 ;
// Now draw the surfaces in this leaf
render - > DrawTranslucentSurfaces ( m_pWorldRenderList , nActualLeafIndex , nEngineDrawFlags , bShadowDepth ) ;
}
// Queue up detail props that existed in this leaf
if ( ClientLeafSystem ( ) - > ShouldDrawDetailObjectsInLeaf ( info . m_pLeafList [ iCurLeafIndex ] , m_pMainView - > BuildWorldListsNumber ( ) ) )
{
pDetailLeafList [ nDetailLeafCount ] = info . m_pLeafList [ iCurLeafIndex ] ;
+ + nDetailLeafCount ;
}
}
}
//-----------------------------------------------------------------------------
// Renders all translucent entities in the render list
//-----------------------------------------------------------------------------
static inline void DrawTranslucentRenderable ( IClientRenderable * pEnt , bool twoPass , bool bShadowDepth , bool bIgnoreDepth )
{
// Determine blending amount and tell engine
float blend = ( float ) ( pEnt - > GetFxBlend ( ) / 255.0f ) ;
// Totally gone
if ( blend < = 0.0f )
return ;
if ( pEnt - > IgnoresZBuffer ( ) ! = bIgnoreDepth )
return ;
// Tell engine
render - > SetBlend ( blend ) ;
float color [ 3 ] ;
pEnt - > GetColorModulation ( color ) ;
render - > SetColorModulation ( color ) ;
int flags = STUDIO_RENDER | STUDIO_TRANSPARENCY ;
if ( twoPass )
flags | = STUDIO_TWOPASS ;
if ( bShadowDepth )
flags | = STUDIO_SHADOWDEPTHTEXTURE ;
float * pRenderClipPlane = NULL ;
if ( r_entityclips . GetBool ( ) )
pRenderClipPlane = pEnt - > GetRenderClipPlane ( ) ;
if ( pRenderClipPlane )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
if ( ! materials - > UsingFastClipping ( ) ) //do NOT change the fast clip plane mid-scene, depth problems result. Regular user clip planes are fine though
pRenderContext - > PushCustomClipPlane ( pRenderClipPlane ) ;
else
DrawClippedDepthBox ( pEnt , pRenderClipPlane ) ;
Assert ( view - > GetCurrentlyDrawingEntity ( ) = = NULL ) ;
view - > SetCurrentlyDrawingEntity ( pEnt - > GetIClientUnknown ( ) - > GetBaseEntity ( ) ) ;
pEnt - > DrawModel ( flags ) ;
view - > SetCurrentlyDrawingEntity ( NULL ) ;
if ( pRenderClipPlane & & ! materials - > UsingFastClipping ( ) )
pRenderContext - > PopCustomClipPlane ( ) ;
}
else
{
Assert ( view - > GetCurrentlyDrawingEntity ( ) = = NULL ) ;
view - > SetCurrentlyDrawingEntity ( pEnt - > GetIClientUnknown ( ) - > GetBaseEntity ( ) ) ;
pEnt - > DrawModel ( flags ) ;
view - > SetCurrentlyDrawingEntity ( NULL ) ;
}
}
//-----------------------------------------------------------------------------
// Renders all translucent entities in the render list
//-----------------------------------------------------------------------------
void CRendering3dView : : DrawTranslucentRenderablesNoWorld ( bool bInSkybox )
{
VPROF ( " CViewRender::DrawTranslucentRenderablesNoWorld " ) ;
if ( ! m_pMainView - > ShouldDrawEntities ( ) | | ! r_drawtranslucentrenderables . GetBool ( ) )
return ;
// Draw the particle singletons.
DrawParticleSingletons ( bInSkybox ) ;
bool bShadowDepth = ( m_DrawFlags & ( DF_SHADOW_DEPTH_MAP | DF_SSAO_DEPTH_PASS ) ) ! = 0 ;
CClientRenderablesList : : CEntry * pEntities = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_TRANSLUCENT_ENTITY ] ;
int iCurTranslucentEntity = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_TRANSLUCENT_ENTITY ] - 1 ;
while ( iCurTranslucentEntity > = 0 )
{
IClientRenderable * pRenderable = pEntities [ iCurTranslucentEntity ] . m_pRenderable ;
if ( pRenderable - > UsesPowerOfTwoFrameBufferTexture ( ) )
{
UpdateRefractTexture ( ) ;
}
if ( pRenderable - > UsesFullFrameBufferTexture ( ) )
{
UpdateScreenEffectTexture ( ) ;
}
DrawTranslucentRenderable ( pRenderable , pEntities [ iCurTranslucentEntity ] . m_TwoPass ! = 0 , bShadowDepth , false ) ;
- - iCurTranslucentEntity ;
}
// Reset the blend state.
render - > SetBlend ( 1 ) ;
}
//-----------------------------------------------------------------------------
// Renders all translucent entities in the render list that ignore the Z buffer
//-----------------------------------------------------------------------------
void CRendering3dView : : DrawNoZBufferTranslucentRenderables ( void )
{
VPROF ( " CViewRender::DrawNoZBufferTranslucentRenderables " ) ;
if ( ! m_pMainView - > ShouldDrawEntities ( ) | | ! r_drawtranslucentrenderables . GetBool ( ) )
return ;
bool bShadowDepth = ( m_DrawFlags & ( DF_SHADOW_DEPTH_MAP | DF_SSAO_DEPTH_PASS ) ) ! = 0 ;
CClientRenderablesList : : CEntry * pEntities = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_TRANSLUCENT_ENTITY ] ;
int iCurTranslucentEntity = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_TRANSLUCENT_ENTITY ] - 1 ;
while ( iCurTranslucentEntity > = 0 )
{
IClientRenderable * pRenderable = pEntities [ iCurTranslucentEntity ] . m_pRenderable ;
if ( pRenderable - > UsesPowerOfTwoFrameBufferTexture ( ) )
{
UpdateRefractTexture ( ) ;
}
if ( pRenderable - > UsesFullFrameBufferTexture ( ) )
{
UpdateScreenEffectTexture ( ) ;
}
DrawTranslucentRenderable ( pRenderable , pEntities [ iCurTranslucentEntity ] . m_TwoPass ! = 0 , bShadowDepth , true ) ;
- - iCurTranslucentEntity ;
}
// Reset the blend state.
render - > SetBlend ( 1 ) ;
}
//-----------------------------------------------------------------------------
// Renders all translucent world, entities, and detail objects in a particular set of leaves
//-----------------------------------------------------------------------------
void CRendering3dView : : DrawTranslucentRenderables ( bool bInSkybox , bool bShadowDepth )
{
const ClientWorldListInfo_t & info = * m_pWorldListInfo ;
# ifdef PORTAL //if we're in the portal mod, we need to make a detour so we can render portal views using stencil areas
if ( ShouldDrawPortals ( ) ) //no recursive stencil views during skybox rendering (although we might be drawing a skybox while already in a recursive stencil view)
{
int iDrawFlagsBackup = m_DrawFlags ;
if ( g_pPortalRender - > DrawPortalsUsingStencils ( ( CViewRender * ) m_pMainView ) ) // @MULTICORE (toml 8/10/2006): remove this hack cast
{
m_DrawFlags = iDrawFlagsBackup ;
//reset visibility
unsigned int iVisFlags = 0 ;
m_pMainView - > SetupVis ( * this , iVisFlags , m_pCustomVisibility ) ;
//recreate drawlists (since I can't find an easy way to backup the originals)
{
SafeRelease ( m_pWorldRenderList ) ;
SafeRelease ( m_pWorldListInfo ) ;
BuildWorldRenderLists ( ( ( m_DrawFlags & DF_DRAW_ENTITITES ) ! = 0 ) , m_pCustomVisibility ? m_pCustomVisibility - > m_iForceViewLeaf : - 1 , false ) ;
AssertMsg ( m_DrawFlags & DF_DRAW_ENTITITES , " It shouldn't be possible to get here if this wasn't set, needs special case investigation " ) ;
for ( int i = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_TRANSLUCENT_ENTITY ] ; - - i > = 0 ; )
{
m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_TRANSLUCENT_ENTITY ] [ i ] . m_pRenderable - > ComputeFxBlend ( ) ;
}
}
if ( r_depthoverlay . GetBool ( ) )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * pDepthTex = GetFullFrameDepthTexture ( ) ;
IMaterial * pMaterial = materials - > FindMaterial ( " debug/showz " , TEXTURE_GROUP_OTHER , true ) ;
pMaterial - > IncrementReferenceCount ( ) ;
IMaterialVar * BaseTextureVar = pMaterial - > FindVar ( " $basetexture " , NULL , false ) ;
IMaterialVar * pDepthInAlpha = NULL ;
if ( IsPC ( ) )
{
pDepthInAlpha = pMaterial - > FindVar ( " $ALPHADEPTH " , NULL , false ) ;
pDepthInAlpha - > SetIntValue ( 1 ) ;
}
BaseTextureVar - > SetTextureValue ( pDepthTex ) ;
pRenderContext - > OverrideDepthEnable ( true , false ) ; //don't write to depth, or else we'll never see translucents
pRenderContext - > DrawScreenSpaceQuad ( pMaterial ) ;
pRenderContext - > OverrideDepthEnable ( false , true ) ;
pMaterial - > DecrementReferenceCount ( ) ;
}
}
else
{
//done recursing in, time to go back out and do translucents
CMatRenderContextPtr pRenderContext ( materials ) ;
UpdateFullScreenDepthTexture ( ) ;
}
}
# else
{
//opaques generally write depth, and translucents generally don't.
//So immediately after opaques are done is the best time to snap off the depth buffer to a texture.
switch ( g_CurrentViewID )
{
case VIEW_MAIN :
# ifdef _X360
case VIEW_INTRO_CAMERA :
case VIEW_INTRO_PLAYER :
# endif
UpdateFullScreenDepthTexture ( ) ;
break ;
default :
materials - > GetRenderContext ( ) - > SetFullScreenDepthTextureValidityFlag ( false ) ;
break ;
}
}
# endif
if ( ! r_drawtranslucentworld . GetBool ( ) )
{
DrawTranslucentRenderablesNoWorld ( bInSkybox ) ;
return ;
}
VPROF_BUDGET ( " CViewRender::DrawTranslucentRenderables " , " DrawTranslucentRenderables " ) ;
int iPrevLeaf = info . m_LeafCount - 1 ;
int nDetailLeafCount = 0 ;
LeafIndex_t * pDetailLeafList = ( LeafIndex_t * ) stackalloc ( info . m_LeafCount * sizeof ( LeafIndex_t ) ) ;
// bool bDrawUnderWater = (nFlags & DF_RENDER_UNDERWATER) != 0;
// bool bDrawAboveWater = (nFlags & DF_RENDER_ABOVEWATER) != 0;
// bool bDrawWater = (nFlags & DF_RENDER_WATER) != 0;
// bool bClipSkybox = (nFlags & DF_CLIP_SKYBOX ) != 0;
unsigned long nEngineDrawFlags = BuildEngineDrawWorldListFlags ( m_DrawFlags & ~ DF_DRAWSKYBOX ) ;
DetailObjectSystem ( ) - > BeginTranslucentDetailRendering ( ) ;
if ( m_pMainView - > ShouldDrawEntities ( ) & & r_drawtranslucentrenderables . GetBool ( ) )
{
MDLCACHE_CRITICAL_SECTION ( ) ;
// Draw the particle singletons.
DrawParticleSingletons ( bInSkybox ) ;
CClientRenderablesList : : CEntry * pEntities = m_pRenderablesList - > m_RenderGroups [ RENDER_GROUP_TRANSLUCENT_ENTITY ] ;
int iCurTranslucentEntity = m_pRenderablesList - > m_RenderGroupCounts [ RENDER_GROUP_TRANSLUCENT_ENTITY ] - 1 ;
bool bRenderingWaterRenderTargets = m_DrawFlags & ( DF_RENDER_REFRACTION | DF_RENDER_REFLECTION ) ;
while ( iCurTranslucentEntity > = 0 )
{
// Seek the current leaf up to our current translucent-entity leaf.
int iThisLeaf = pEntities [ iCurTranslucentEntity ] . m_iWorldListInfoLeaf ;
// First draw the translucent parts of the world up to and including those in this leaf
DrawTranslucentWorldAndDetailPropsInLeaves ( iPrevLeaf , iThisLeaf , nEngineDrawFlags , nDetailLeafCount , pDetailLeafList , bShadowDepth ) ;
// We're traversing the leaf list backwards to get the appropriate sort ordering (back to front)
iPrevLeaf = iThisLeaf - 1 ;
// Draw all the translucent entities with this leaf.
int nLeaf = info . m_pLeafList [ iThisLeaf ] ;
bool bDrawDetailProps = ClientLeafSystem ( ) - > ShouldDrawDetailObjectsInLeaf ( nLeaf , m_pMainView - > BuildWorldListsNumber ( ) ) ;
if ( bDrawDetailProps )
{
// Draw detail props up to but not including this leaf
Assert ( nDetailLeafCount > 0 ) ;
- - nDetailLeafCount ;
Assert ( pDetailLeafList [ nDetailLeafCount ] = = nLeaf ) ;
DetailObjectSystem ( ) - > RenderTranslucentDetailObjects ( CurrentViewOrigin ( ) , CurrentViewForward ( ) , CurrentViewRight ( ) , CurrentViewUp ( ) , nDetailLeafCount , pDetailLeafList ) ;
// Draw translucent renderables in the leaf interspersed with detail props
for ( ; pEntities [ iCurTranslucentEntity ] . m_iWorldListInfoLeaf = = iThisLeaf & & iCurTranslucentEntity > = 0 ; - - iCurTranslucentEntity )
{
IClientRenderable * pRenderable = pEntities [ iCurTranslucentEntity ] . m_pRenderable ;
// Draw any detail props in this leaf that's farther than the entity
const Vector & vecRenderOrigin = pRenderable - > GetRenderOrigin ( ) ;
DetailObjectSystem ( ) - > RenderTranslucentDetailObjectsInLeaf ( CurrentViewOrigin ( ) , CurrentViewForward ( ) , CurrentViewRight ( ) , CurrentViewUp ( ) , nLeaf , & vecRenderOrigin ) ;
bool bUsesPowerOfTwoFB = pRenderable - > UsesPowerOfTwoFrameBufferTexture ( ) ;
bool bUsesFullFB = pRenderable - > UsesFullFrameBufferTexture ( ) ;
if ( ( bUsesPowerOfTwoFB | | bUsesFullFB ) & & ! bShadowDepth )
{
if ( bRenderingWaterRenderTargets )
{
continue ;
}
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * rt = pRenderContext - > GetRenderTarget ( ) ;
if ( rt & & bUsesFullFB )
{
UpdateScreenEffectTexture ( 0 , 0 , 0 , rt - > GetActualWidth ( ) , rt - > GetActualHeight ( ) , true ) ;
}
else if ( bUsesPowerOfTwoFB )
{
UpdateRefractTexture ( ) ;
}
pRenderContext . SafeRelease ( ) ;
}
// Then draw the translucent renderable
DrawTranslucentRenderable ( pRenderable , ( pEntities [ iCurTranslucentEntity ] . m_TwoPass ! = 0 ) , bShadowDepth , false ) ;
}
// Draw all remaining props in this leaf
DetailObjectSystem ( ) - > RenderTranslucentDetailObjectsInLeaf ( CurrentViewOrigin ( ) , CurrentViewForward ( ) , CurrentViewRight ( ) , CurrentViewUp ( ) , nLeaf , NULL ) ;
}
else
{
// Draw queued up detail props (we know that the list of detail leaves won't include this leaf, since ShouldDrawDetailObjectsInLeaf is false)
// Therefore no fixup on nDetailLeafCount is required as in the above section
DetailObjectSystem ( ) - > RenderTranslucentDetailObjects ( CurrentViewOrigin ( ) , CurrentViewForward ( ) , CurrentViewRight ( ) , CurrentViewUp ( ) , nDetailLeafCount , pDetailLeafList ) ;
for ( ; pEntities [ iCurTranslucentEntity ] . m_iWorldListInfoLeaf = = iThisLeaf & & iCurTranslucentEntity > = 0 ; - - iCurTranslucentEntity )
{
IClientRenderable * pRenderable = pEntities [ iCurTranslucentEntity ] . m_pRenderable ;
bool bUsesPowerOfTwoFB = pRenderable - > UsesPowerOfTwoFrameBufferTexture ( ) ;
bool bUsesFullFB = pRenderable - > UsesFullFrameBufferTexture ( ) ;
if ( ( bUsesPowerOfTwoFB | | bUsesFullFB ) & & ! bShadowDepth )
{
if ( bRenderingWaterRenderTargets )
{
continue ;
}
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * rt = pRenderContext - > GetRenderTarget ( ) ;
if ( rt )
{
if ( bUsesFullFB )
{
UpdateScreenEffectTexture ( 0 , 0 , 0 , rt - > GetActualWidth ( ) , rt - > GetActualHeight ( ) , true ) ;
}
else if ( bUsesPowerOfTwoFB )
{
UpdateRefractTexture ( 0 , 0 , rt - > GetActualWidth ( ) , rt - > GetActualHeight ( ) ) ;
}
}
else
{
if ( bUsesPowerOfTwoFB )
{
UpdateRefractTexture ( ) ;
}
}
pRenderContext . SafeRelease ( ) ;
}
DrawTranslucentRenderable ( pRenderable , ( pEntities [ iCurTranslucentEntity ] . m_TwoPass ! = 0 ) , bShadowDepth , false ) ;
}
}
nDetailLeafCount = 0 ;
}
}
// Draw the rest of the surfaces in world leaves
DrawTranslucentWorldAndDetailPropsInLeaves ( iPrevLeaf , 0 , nEngineDrawFlags , nDetailLeafCount , pDetailLeafList , bShadowDepth ) ;
// Draw any queued-up detail props from previously visited leaves
DetailObjectSystem ( ) - > RenderTranslucentDetailObjects ( CurrentViewOrigin ( ) , CurrentViewForward ( ) , CurrentViewRight ( ) , CurrentViewUp ( ) , nDetailLeafCount , pDetailLeafList ) ;
// Reset the blend state.
render - > SetBlend ( 1 ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CRendering3dView : : EnableWorldFog ( void )
{
VPROF ( " CViewRender::EnableWorldFog " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
fogparams_t * pFogParams = NULL ;
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( pbp )
{
pFogParams = pbp - > GetFogParams ( ) ;
}
if ( GetFogEnable ( pFogParams ) )
{
float fogColor [ 3 ] ;
GetFogColor ( pFogParams , fogColor ) ;
pRenderContext - > FogMode ( MATERIAL_FOG_LINEAR ) ;
pRenderContext - > FogColor3fv ( fogColor ) ;
pRenderContext - > FogStart ( GetFogStart ( pFogParams ) ) ;
pRenderContext - > FogEnd ( GetFogEnd ( pFogParams ) ) ;
pRenderContext - > FogMaxDensity ( GetFogMaxDensity ( pFogParams ) ) ;
}
else
{
pRenderContext - > FogMode ( MATERIAL_FOG_NONE ) ;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CRendering3dView : : GetDrawFlags ( )
{
return m_DrawFlags ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CRendering3dView : : SetFogVolumeState ( const VisibleFogVolumeInfo_t & fogInfo , bool bUseHeightFog )
{
render - > SetFogVolumeState ( fogInfo . m_nVisibleFogVolume , bUseHeightFog ) ;
# ifdef PORTAL
//the idea behind fog shifting is this...
//Normal fog simulates the effect of countless tiny particles between your viewpoint and whatever geometry is rendering.
//But, when rendering to a portal view, there's a large space between the virtual camera and the portal exit surface.
//This space isn't supposed to exist, and therefore has none of the tiny particles that make up fog.
//So, we have to shift fog start/end out to align the distances with the portal exit surface instead of the virtual camera to eliminate fog simulation in the non-space
if ( g_pPortalRender - > GetViewRecursionLevel ( ) = = 0 )
return ; //rendering one of the primary views, do nothing
g_pPortalRender - > ShiftFogForExitPortalView ( ) ;
# endif //#ifdef PORTAL
}
//-----------------------------------------------------------------------------
// Standard 3d skybox view
//-----------------------------------------------------------------------------
SkyboxVisibility_t CSkyboxView : : ComputeSkyboxVisibility ( )
{
return engine - > IsSkyboxVisibleFromPoint ( origin ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CSkyboxView : : GetSkyboxFogEnable ( )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp )
{
return false ;
}
CPlayerLocalData * local = & pbp - > m_Local ;
if ( fog_override . GetInt ( ) )
{
if ( fog_enableskybox . GetInt ( ) )
{
return true ;
}
else
{
return false ;
}
}
else
{
return ! ! local - > m_skybox3d . fog . enable ;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CSkyboxView : : Enable3dSkyboxFog ( void )
{
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ! pbp )
{
return ;
}
CPlayerLocalData * local = & pbp - > m_Local ;
CMatRenderContextPtr pRenderContext ( materials ) ;
if ( GetSkyboxFogEnable ( ) )
{
float fogColor [ 3 ] ;
GetSkyboxFogColor ( fogColor ) ;
float scale = 1.0f ;
if ( local - > m_skybox3d . scale > 0.0f )
{
scale = 1.0f / local - > m_skybox3d . scale ;
}
pRenderContext - > FogMode ( MATERIAL_FOG_LINEAR ) ;
pRenderContext - > FogColor3fv ( fogColor ) ;
pRenderContext - > FogStart ( GetSkyboxFogStart ( ) * scale ) ;
pRenderContext - > FogEnd ( GetSkyboxFogEnd ( ) * scale ) ;
pRenderContext - > FogMaxDensity ( GetSkyboxFogMaxDensity ( ) ) ;
}
else
{
pRenderContext - > FogMode ( MATERIAL_FOG_NONE ) ;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
sky3dparams_t * CSkyboxView : : PreRender3dSkyboxWorld ( SkyboxVisibility_t nSkyboxVisible )
{
if ( ( nSkyboxVisible ! = SKYBOX_3DSKYBOX_VISIBLE ) & & r_3dsky . GetInt ( ) ! = 2 )
return NULL ;
// render the 3D skybox
if ( ! r_3dsky . GetInt ( ) )
return NULL ;
C_BasePlayer * pbp = C_BasePlayer : : GetLocalPlayer ( ) ;
// No local player object yet...
if ( ! pbp )
return NULL ;
CPlayerLocalData * local = & pbp - > m_Local ;
if ( local - > m_skybox3d . area = = 255 )
return NULL ;
return & local - > m_skybox3d ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CSkyboxView : : DrawInternal ( view_id_t iSkyBoxViewID , bool bInvokePreAndPostRender , ITexture * pRenderTarget , ITexture * pDepthTarget )
{
unsigned char * * areabits = render - > GetAreaBits ( ) ;
unsigned char * savebits ;
unsigned char tmpbits [ 32 ] ;
savebits = * areabits ;
memset ( tmpbits , 0 , sizeof ( tmpbits ) ) ;
// set the sky area bit
tmpbits [ m_pSky3dParams - > area > > 3 ] | = 1 < < ( m_pSky3dParams - > area & 7 ) ;
* areabits = tmpbits ;
// if you can get really close to the skybox geometry it's possible that you'll be able to clip into it
// with this near plane. If so, move it in a bit. It's at 2.0 to give us more precision. That means you
// need to keep the eye position at least 2 * scale away from the geometry in the skybox
zNear = 2.0 ;
zFar = MAX_TRACE_LENGTH ;
// scale origin by sky scale
if ( m_pSky3dParams - > scale > 0 )
{
float scale = 1.0f / m_pSky3dParams - > scale ;
VectorScale ( origin , scale , origin ) ;
}
Enable3dSkyboxFog ( ) ;
VectorAdd ( origin , m_pSky3dParams - > origin , origin ) ;
// BUGBUG: Fix this!!! We shouldn't need to call setup vis for the sky if we're connecting
// the areas. We'd have to mark all the clusters in the skybox area in the PVS of any
// cluster with sky. Then we could just connect the areas to do our vis.
//m_bOverrideVisOrigin could hose us here, so call direct
render - > ViewSetupVis ( false , 1 , & m_pSky3dParams - > origin . Get ( ) ) ;
render - > Push3DView ( ( * this ) , m_ClearFlags , pRenderTarget , GetFrustum ( ) , pDepthTarget ) ;
// Store off view origin and angles
SetupCurrentView ( origin , angles , iSkyBoxViewID ) ;
# if defined( _X360 )
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > PushVertexShaderGPRAllocation ( 32 ) ;
pRenderContext . SafeRelease ( ) ;
# endif
// Invoke pre-render methods
if ( bInvokePreAndPostRender )
{
IGameSystem : : PreRenderAllSystems ( ) ;
}
render - > BeginUpdateLightmaps ( ) ;
BuildWorldRenderLists ( true , true , - 1 ) ;
BuildRenderableRenderLists ( iSkyBoxViewID ) ;
render - > EndUpdateLightmaps ( ) ;
g_pClientShadowMgr - > ComputeShadowTextures ( ( * this ) , m_pWorldListInfo - > m_LeafCount , m_pWorldListInfo - > m_pLeafList ) ;
DrawWorld ( 0.0f ) ;
// Iterate over all leaves and render objects in those leaves
DrawOpaqueRenderables ( DEPTH_MODE_NORMAL ) ;
// Iterate over all leaves and render objects in those leaves
DrawTranslucentRenderables ( true , false ) ;
DrawNoZBufferTranslucentRenderables ( ) ;
m_pMainView - > DisableFog ( ) ;
CGlowOverlay : : UpdateSkyOverlays ( zFar , m_bCacheFullSceneState ) ;
PixelVisibility_EndCurrentView ( ) ;
// restore old area bits
* areabits = savebits ;
// Invoke post-render methods
if ( bInvokePreAndPostRender )
{
IGameSystem : : PostRenderAllSystems ( ) ;
FinishCurrentView ( ) ;
}
render - > PopView ( GetFrustum ( ) ) ;
# if defined( _X360 )
pRenderContext . GetFrom ( materials ) ;
pRenderContext - > PopVertexShaderGPRAllocation ( ) ;
# endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CSkyboxView : : Setup ( const CViewSetup & view , int * pClearFlags , SkyboxVisibility_t * pSkyboxVisible )
{
BaseClass : : Setup ( view ) ;
// The skybox might not be visible from here
* pSkyboxVisible = ComputeSkyboxVisibility ( ) ;
m_pSky3dParams = PreRender3dSkyboxWorld ( * pSkyboxVisible ) ;
if ( ! m_pSky3dParams )
{
return false ;
}
// At this point, we've cleared everything we need to clear
// The next path will need to clear depth, though.
m_ClearFlags = * pClearFlags ;
* pClearFlags & = ~ ( VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH | VIEW_CLEAR_STENCIL | VIEW_CLEAR_FULL_TARGET ) ;
* pClearFlags | = VIEW_CLEAR_DEPTH ; // Need to clear depth after rednering the skybox
m_DrawFlags = DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER | DF_RENDER_WATER ;
if ( r_skybox . GetBool ( ) )
{
m_DrawFlags | = DF_DRAWSKYBOX ;
}
return true ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CSkyboxView : : Draw ( )
{
VPROF_BUDGET ( " CViewRender::Draw3dSkyboxworld " , " 3D Skybox " ) ;
ITexture * pRTColor = NULL ;
ITexture * pRTDepth = NULL ;
if ( m_eStereoEye ! = STEREO_EYE_MONO )
{
pRTColor = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Color ) ;
pRTDepth = g_pSourceVR - > GetRenderTarget ( ( ISourceVirtualReality : : VREye ) ( m_eStereoEye - 1 ) , ISourceVirtualReality : : RT_Depth ) ;
}
DrawInternal ( VIEW_3DSKY , true , pRTColor , pRTDepth ) ;
}
# ifdef PORTAL
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CPortalSkyboxView : : Setup ( const CViewSetup & view , int * pClearFlags , SkyboxVisibility_t * pSkyboxVisible , ITexture * pRenderTarget )
{
if ( ! BaseClass : : Setup ( view , pClearFlags , pSkyboxVisible ) )
return false ;
m_pRenderTarget = pRenderTarget ;
return true ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
SkyboxVisibility_t CPortalSkyboxView : : ComputeSkyboxVisibility ( )
{
return g_pPortalRender - > IsSkyboxVisibleFromExitPortal ( ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CPortalSkyboxView : : Draw ( )
{
AssertMsg ( ( g_pPortalRender - > GetViewRecursionLevel ( ) ! = 0 ) & & g_pPortalRender - > IsRenderingPortal ( ) , " This is designed for through-portal views. Use the regular skybox drawing code for primary views " ) ;
VPROF_BUDGET ( " CViewRender::Draw3dSkyboxworld_Portal " , " 3D Skybox (portal view) " ) ;
int iCurrentViewID = g_CurrentViewID ;
Frustum FrustumBackup ;
memcpy ( FrustumBackup , GetFrustum ( ) , sizeof ( Frustum ) ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
bool bClippingEnabled = pRenderContext - > EnableClipping ( false ) ;
//NOTE: doesn't magically map to VIEW_3DSKY at (0,0) like PORTAL_VIEWID maps to VIEW_MAIN
view_id_t iSkyBoxViewID = ( view_id_t ) g_pPortalRender - > GetCurrentSkyboxViewId ( ) ;
bool bInvokePreAndPostRender = ( g_pPortalRender - > ShouldUseStencilsToRenderPortals ( ) = = false ) ;
DrawInternal ( iSkyBoxViewID , bInvokePreAndPostRender , m_pRenderTarget , NULL ) ;
pRenderContext - > EnableClipping ( bClippingEnabled ) ;
memcpy ( GetFrustum ( ) , FrustumBackup , sizeof ( Frustum ) ) ;
render - > OverrideViewFrustum ( FrustumBackup ) ;
g_CurrentViewID = iCurrentViewID ;
}
# endif // PORTAL
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CShadowDepthView : : Setup ( const CViewSetup & shadowViewIn , ITexture * pRenderTarget , ITexture * pDepthTexture )
{
BaseClass : : Setup ( shadowViewIn ) ;
m_pRenderTarget = pRenderTarget ;
m_pDepthTexture = pDepthTexture ;
}
bool DrawingShadowDepthView ( void ) //for easy externing
{
return ( CurrentViewID ( ) = = VIEW_SHADOW_DEPTH_TEXTURE ) ;
}
bool DrawingMainView ( ) //for easy externing
{
return ( CurrentViewID ( ) = = VIEW_MAIN ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CShadowDepthView : : Draw ( )
{
VPROF_BUDGET ( " CShadowDepthView::Draw " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
// Start view
unsigned int visFlags ;
m_pMainView - > SetupVis ( ( * this ) , visFlags ) ; // @MULTICORE (toml 8/9/2006): Portal problem, not sending custom vis down
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > ClearColor3ub ( 0xFF , 0xFF , 0xFF ) ;
# if defined( _X360 )
pRenderContext - > PushVertexShaderGPRAllocation ( 112 ) ; //almost all work is done in vertex shaders for depth rendering, max out their threads
# endif
pRenderContext . SafeRelease ( ) ;
if ( IsPC ( ) )
{
render - > Push3DView ( ( * this ) , VIEW_CLEAR_DEPTH , m_pRenderTarget , GetFrustum ( ) , m_pDepthTexture ) ;
}
else if ( IsX360 ( ) )
{
//for the 360, the dummy render target has a separate depth buffer which we Resolve() from afterward
render - > Push3DView ( ( * this ) , VIEW_CLEAR_DEPTH , m_pRenderTarget , GetFrustum ( ) ) ;
}
SetupCurrentView ( origin , angles , VIEW_SHADOW_DEPTH_TEXTURE ) ;
MDLCACHE_CRITICAL_SECTION ( ) ;
{
VPROF_BUDGET ( " BuildWorldRenderLists " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
BuildWorldRenderLists ( true , - 1 , true , true ) ; // @MULTICORE (toml 8/9/2006): Portal problem, not sending custom vis down
}
{
VPROF_BUDGET ( " BuildRenderableRenderLists " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
BuildRenderableRenderLists ( CurrentViewID ( ) ) ;
}
engine - > Sound_ExtraUpdate ( ) ; // Make sure sound doesn't stutter
m_DrawFlags = m_pMainView - > GetBaseDrawFlags ( ) | DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER | DF_SHADOW_DEPTH_MAP ; // Don't draw water surface...
{
VPROF_BUDGET ( " DrawWorld " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
DrawWorld ( 0.0f ) ;
}
// Draw opaque and translucent renderables with appropriate override materials
// OVERRIDE_DEPTH_WRITE is OK with a NULL material pointer
modelrender - > ForcedMaterialOverride ( NULL , OVERRIDE_DEPTH_WRITE ) ;
{
VPROF_BUDGET ( " DrawOpaqueRenderables " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
DrawOpaqueRenderables ( DEPTH_MODE_SHADOW ) ;
}
modelrender - > ForcedMaterialOverride ( 0 ) ;
m_DrawFlags = 0 ;
pRenderContext . GetFrom ( materials ) ;
if ( IsX360 ( ) )
{
//Resolve() the depth texture here. Before the pop so the copy will recognize that the resolutions are the same
pRenderContext - > CopyRenderTargetToTextureEx ( m_pDepthTexture , - 1 , NULL , NULL ) ;
}
render - > PopView ( GetFrustum ( ) ) ;
# if defined( _X360 )
pRenderContext - > PopVertexShaderGPRAllocation ( ) ;
# endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CFreezeFrameView : : Setup ( const CViewSetup & shadowViewIn )
{
BaseClass : : Setup ( shadowViewIn ) ;
KeyValues * pVMTKeyValues = new KeyValues ( " UnlitGeneric " ) ;
pVMTKeyValues - > SetString ( " $basetexture " , IsX360 ( ) ? " _rt_FullFrameFB1 " : " _rt_FullScreen " ) ;
pVMTKeyValues - > SetInt ( " $nocull " , 1 ) ;
pVMTKeyValues - > SetInt ( " $nofog " , 1 ) ;
pVMTKeyValues - > SetInt ( " $ignorez " , 1 ) ;
m_pFreezeFrame . Init ( " FreezeFrame_FullScreen " , TEXTURE_GROUP_OTHER , pVMTKeyValues ) ;
m_pFreezeFrame - > Refresh ( ) ;
m_TranslucentSingleColor . Init ( " debug/debugtranslucentsinglecolor " , TEXTURE_GROUP_OTHER ) ;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CFreezeFrameView : : Draw ( void )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
# if defined( _X360 )
pRenderContext - > PushVertexShaderGPRAllocation ( 16 ) ; //max out pixel shader threads
# endif
// we might only need half of the texture if we're rendering in stereo
int nTexX0 = 0 , nTexY0 = 0 ;
int nTexX1 = width , nTexY1 = height ;
int nTexWidth = width , nTexHeight = height ;
switch ( m_eStereoEye )
{
case STEREO_EYE_LEFT :
nTexX1 = width ;
nTexWidth * = 2 ;
break ;
case STEREO_EYE_RIGHT :
nTexX0 = width ;
nTexX1 = width * 2 ;
nTexWidth * = 2 ;
break ;
}
pRenderContext - > DrawScreenSpaceRectangle ( m_pFreezeFrame , x , y , width , height ,
nTexX0 , nTexY0 , nTexX1 - 1 , nTexY1 - 1 , nTexWidth , nTexHeight ) ;
//Fake a fade during freezeframe view.
if ( g_flFreezeFlash > = gpGlobals - > curtime & & engine - > IsTakingScreenshot ( ) = = false )
{
// Overlay screen fade on entire screen
IMaterial * pMaterial = m_TranslucentSingleColor ;
int iFadeAlpha = FREEZECAM_SNAPSHOT_FADE_SPEED * ( g_flFreezeFlash - gpGlobals - > curtime ) ;
iFadeAlpha = MIN ( iFadeAlpha , 255 ) ;
iFadeAlpha = MAX ( 0 , iFadeAlpha ) ;
pMaterial - > AlphaModulate ( iFadeAlpha * ( 1.0f / 255.0f ) ) ;
pMaterial - > ColorModulate ( 1.0f , 1.0f , 1.0f ) ;
pMaterial - > SetMaterialVarFlag ( MATERIAL_VAR_IGNOREZ , true ) ;
pRenderContext - > DrawScreenSpaceRectangle ( pMaterial , x , y , width , height , 0 , 0 , width - 1 , height - 1 , width , height ) ;
}
# if defined( _X360 )
pRenderContext - > PopVertexShaderGPRAllocation ( ) ;
# endif
}
//-----------------------------------------------------------------------------
// Pops a water render target
//-----------------------------------------------------------------------------
bool CBaseWorldView : : AdjustView ( float waterHeight )
{
if ( m_DrawFlags & DF_RENDER_REFRACTION )
{
ITexture * pTexture = GetWaterRefractionTexture ( ) ;
// Use the aspect ratio of the main view! So, don't recompute it here
x = y = 0 ;
width = pTexture - > GetActualWidth ( ) ;
height = pTexture - > GetActualHeight ( ) ;
return true ;
}
if ( m_DrawFlags & DF_RENDER_REFLECTION )
{
ITexture * pTexture = GetWaterReflectionTexture ( ) ;
// If the main view is overriding the projection matrix (for Stereo or
// some other nefarious purpose) make sure to include any Y offset in
// the custom projection matrix in our reflected overridden projection
// matrix.
if ( m_bViewToProjectionOverride )
{
m_ViewToProjection [ 1 ] [ 2 ] = - m_ViewToProjection [ 1 ] [ 2 ] ;
}
// Use the aspect ratio of the main view! So, don't recompute it here
x = y = 0 ;
width = pTexture - > GetActualWidth ( ) ;
height = pTexture - > GetActualHeight ( ) ;
angles [ 0 ] = - angles [ 0 ] ;
angles [ 2 ] = - angles [ 2 ] ;
origin [ 2 ] - = 2.0f * ( origin [ 2 ] - ( waterHeight ) ) ;
return true ;
}
return false ;
}
//-----------------------------------------------------------------------------
// Pops a water render target
//-----------------------------------------------------------------------------
void CBaseWorldView : : PushView ( float waterHeight )
{
float spread = 2.0f ;
if ( m_DrawFlags & DF_FUDGE_UP )
{
waterHeight + = spread ;
}
else
{
waterHeight - = spread ;
}
MaterialHeightClipMode_t clipMode = MATERIAL_HEIGHTCLIPMODE_DISABLE ;
if ( ( m_DrawFlags & DF_CLIP_Z ) & & mat_clipz . GetBool ( ) )
{
if ( m_DrawFlags & DF_CLIP_BELOW )
{
clipMode = MATERIAL_HEIGHTCLIPMODE_RENDER_ABOVE_HEIGHT ;
}
else
{
clipMode = MATERIAL_HEIGHTCLIPMODE_RENDER_BELOW_HEIGHT ;
}
}
CMatRenderContextPtr pRenderContext ( materials ) ;
if ( m_DrawFlags & DF_RENDER_REFRACTION )
{
pRenderContext - > SetFogZ ( waterHeight ) ;
pRenderContext - > SetHeightClipZ ( waterHeight ) ;
pRenderContext - > SetHeightClipMode ( clipMode ) ;
// Have to re-set up the view since we reset the size
render - > Push3DView ( * this , m_ClearFlags , GetWaterRefractionTexture ( ) , GetFrustum ( ) ) ;
return ;
}
if ( m_DrawFlags & DF_RENDER_REFLECTION )
{
ITexture * pTexture = GetWaterReflectionTexture ( ) ;
pRenderContext - > SetFogZ ( waterHeight ) ;
bool bSoftwareUserClipPlane = g_pMaterialSystemHardwareConfig - > UseFastClipping ( ) ;
if ( bSoftwareUserClipPlane & & ( origin [ 2 ] > waterHeight - r_eyewaterepsilon . GetFloat ( ) ) )
{
waterHeight = origin [ 2 ] + r_eyewaterepsilon . GetFloat ( ) ;
}
pRenderContext - > SetHeightClipZ ( waterHeight ) ;
pRenderContext - > SetHeightClipMode ( clipMode ) ;
render - > Push3DView ( * this , m_ClearFlags , pTexture , GetFrustum ( ) ) ;
SetLightmapScaleForWater ( ) ;
return ;
}
if ( m_ClearFlags & ( VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR | VIEW_CLEAR_STENCIL ) )
{
if ( m_ClearFlags & VIEW_CLEAR_OBEY_STENCIL )
{
pRenderContext - > ClearBuffersObeyStencil ( m_ClearFlags & VIEW_CLEAR_COLOR , m_ClearFlags & VIEW_CLEAR_DEPTH ) ;
}
else
{
pRenderContext - > ClearBuffers ( m_ClearFlags & VIEW_CLEAR_COLOR , m_ClearFlags & VIEW_CLEAR_DEPTH , m_ClearFlags & VIEW_CLEAR_STENCIL ) ;
}
}
pRenderContext - > SetHeightClipMode ( clipMode ) ;
if ( clipMode ! = MATERIAL_HEIGHTCLIPMODE_DISABLE )
{
pRenderContext - > SetHeightClipZ ( waterHeight ) ;
}
}
//-----------------------------------------------------------------------------
// Pops a water render target
//-----------------------------------------------------------------------------
void CBaseWorldView : : PopView ( )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > SetHeightClipMode ( MATERIAL_HEIGHTCLIPMODE_DISABLE ) ;
if ( m_DrawFlags & ( DF_RENDER_REFRACTION | DF_RENDER_REFLECTION ) )
{
if ( IsX360 ( ) )
{
// these renders paths used their surfaces, so blit their results
if ( m_DrawFlags & DF_RENDER_REFRACTION )
{
pRenderContext - > CopyRenderTargetToTextureEx ( GetWaterRefractionTexture ( ) , NULL , NULL ) ;
}
if ( m_DrawFlags & DF_RENDER_REFLECTION )
{
pRenderContext - > CopyRenderTargetToTextureEx ( GetWaterReflectionTexture ( ) , NULL , NULL ) ;
}
}
render - > PopView ( GetFrustum ( ) ) ;
if ( SavedLinearLightMapScale . x > = 0 )
{
pRenderContext - > SetToneMappingScaleLinear ( SavedLinearLightMapScale ) ;
SavedLinearLightMapScale . x = - 1 ;
}
}
}
//-----------------------------------------------------------------------------
// Draws the world + entities
//-----------------------------------------------------------------------------
void CBaseWorldView : : DrawSetup ( float waterHeight , int nSetupFlags , float waterZAdjust , int iForceViewLeaf )
{
int savedViewID = g_CurrentViewID ;
g_CurrentViewID = VIEW_ILLEGAL ;
bool bViewChanged = AdjustView ( waterHeight ) ;
if ( bViewChanged )
{
render - > Push3DView ( * this , 0 , NULL , GetFrustum ( ) ) ;
}
render - > BeginUpdateLightmaps ( ) ;
bool bDrawEntities = ( nSetupFlags & DF_DRAW_ENTITITES ) ! = 0 ;
bool bDrawReflection = ( nSetupFlags & DF_RENDER_REFLECTION ) ! = 0 ;
BuildWorldRenderLists ( bDrawEntities , iForceViewLeaf , true , false , bDrawReflection ? & waterHeight : NULL ) ;
PruneWorldListInfo ( ) ;
if ( bDrawEntities )
{
BuildRenderableRenderLists ( savedViewID ) ;
}
render - > EndUpdateLightmaps ( ) ;
if ( bViewChanged )
{
render - > PopView ( GetFrustum ( ) ) ;
}
# ifdef TF_CLIENT_DLL
bool bVisionOverride = ( localplayer_visionflags . GetInt ( ) & ( 0x01 ) ) ; // Pyro-vision Goggles
if ( savedViewID = = VIEW_MAIN & & bVisionOverride & & pyro_dof . GetBool ( ) )
{
SSAO_DepthPass ( ) ;
}
# endif
g_CurrentViewID = savedViewID ;
}
void MaybeInvalidateLocalPlayerAnimation ( )
{
C_BasePlayer * pPlayer = C_BasePlayer : : GetLocalPlayer ( ) ;
if ( ( pPlayer ! = NULL ) & & pPlayer - > InFirstPersonView ( ) )
{
// We sometimes need different animation for the main view versus the shadow rendering,
// so we need to reset the cache to ensure this actually happens.
pPlayer - > InvalidateBoneCache ( ) ;
C_BaseCombatWeapon * pWeapon = pPlayer - > GetActiveWeapon ( ) ;
if ( pWeapon ! = NULL )
{
pWeapon - > InvalidateBoneCache ( ) ;
}
# if defined USES_ECON_ITEMS
// ...and all the things you're wearing/holding/etc
int NumWearables = pPlayer - > GetNumWearables ( ) ;
for ( int i = 0 ; i < NumWearables ; + + i )
{
CEconWearable * pItem = pPlayer - > GetWearable ( i ) ;
if ( pItem ! = NULL )
{
pItem - > InvalidateBoneCache ( ) ;
}
}
# endif // USES_ECON_ITEMS
}
}
void CBaseWorldView : : DrawExecute ( float waterHeight , view_id_t viewID , float waterZAdjust )
{
int savedViewID = g_CurrentViewID ;
// @MULTICORE (toml 8/16/2006): rethink how, where, and when this is done...
g_CurrentViewID = VIEW_SHADOW_DEPTH_TEXTURE ;
MaybeInvalidateLocalPlayerAnimation ( ) ;
g_pClientShadowMgr - > ComputeShadowTextures ( * this , m_pWorldListInfo - > m_LeafCount , m_pWorldListInfo - > m_pLeafList ) ;
MaybeInvalidateLocalPlayerAnimation ( ) ;
// Make sure sound doesn't stutter
engine - > Sound_ExtraUpdate ( ) ;
g_CurrentViewID = viewID ;
// Update our render view flags.
int iDrawFlagsBackup = m_DrawFlags ;
m_DrawFlags | = m_pMainView - > GetBaseDrawFlags ( ) ;
PushView ( waterHeight ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
# if defined( _X360 )
pRenderContext - > PushVertexShaderGPRAllocation ( 32 ) ;
# endif
ITexture * pSaveFrameBufferCopyTexture = pRenderContext - > GetFrameBufferCopyTexture ( 0 ) ;
if ( engine - > GetDXSupportLevel ( ) > = 80 )
{
pRenderContext - > SetFrameBufferCopyTexture ( GetPowerOfTwoFrameBufferTexture ( ) ) ;
}
pRenderContext . SafeRelease ( ) ;
ERenderDepthMode DepthMode = DEPTH_MODE_NORMAL ;
if ( m_DrawFlags & DF_DRAW_ENTITITES )
{
DrawWorld ( waterZAdjust ) ;
DrawOpaqueRenderables ( DepthMode ) ;
# ifdef TF_CLIENT_DLL
bool bVisionOverride = ( localplayer_visionflags . GetInt ( ) & ( 0x01 ) ) ; // Pyro-vision Goggles
if ( g_CurrentViewID = = VIEW_MAIN & & bVisionOverride & & pyro_dof . GetBool ( ) ) // Pyro-vision Goggles
{
DrawDepthOfField ( ) ;
}
# endif
DrawTranslucentRenderables ( false , false ) ;
DrawNoZBufferTranslucentRenderables ( ) ;
}
else
{
DrawWorld ( waterZAdjust ) ;
# ifdef TF_CLIENT_DLL
bool bVisionOverride = ( localplayer_visionflags . GetInt ( ) & ( 0x01 ) ) ; // Pyro-vision Goggles
if ( g_CurrentViewID = = VIEW_MAIN & & bVisionOverride & & pyro_dof . GetBool ( ) ) // Pyro-vision Goggles
{
DrawDepthOfField ( ) ;
}
# endif
// Draw translucent world brushes only, no entities
DrawTranslucentWorldInLeaves ( false ) ;
}
// issue the pixel visibility tests for sub-views
if ( ! IsMainView ( CurrentViewID ( ) ) & & CurrentViewID ( ) ! = VIEW_INTRO_CAMERA )
{
PixelVisibility_EndCurrentView ( ) ;
}
pRenderContext . GetFrom ( materials ) ;
pRenderContext - > SetFrameBufferCopyTexture ( pSaveFrameBufferCopyTexture ) ;
PopView ( ) ;
m_DrawFlags = iDrawFlagsBackup ;
g_CurrentViewID = savedViewID ;
# if defined( _X360 )
pRenderContext - > PopVertexShaderGPRAllocation ( ) ;
# endif
}
void CBaseWorldView : : SSAO_DepthPass ( )
{
if ( ! g_pMaterialSystemHardwareConfig - > SupportsPixelShaders_2_0 ( ) )
{
return ;
}
# if 1
VPROF_BUDGET ( " CSimpleWorldView::SSAO_DepthPass " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
int savedViewID = g_CurrentViewID ;
g_CurrentViewID = VIEW_SSAO ;
ITexture * pSSAO = materials - > FindTexture ( " _rt_ResolvedFullFrameDepth " , TEXTURE_GROUP_RENDER_TARGET ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > ClearColor4ub ( 255 , 255 , 255 , 255 ) ;
# if defined( _X360 )
Assert ( 0 ) ; // rebalance this if we ever use this on 360
pRenderContext - > PushVertexShaderGPRAllocation ( 112 ) ; //almost all work is done in vertex shaders for depth rendering, max out their threads
# endif
pRenderContext . SafeRelease ( ) ;
if ( IsPC ( ) )
{
render - > Push3DView ( ( * this ) , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR , pSSAO , GetFrustum ( ) ) ;
}
else if ( IsX360 ( ) )
{
render - > Push3DView ( ( * this ) , VIEW_CLEAR_DEPTH | VIEW_CLEAR_COLOR , pSSAO , GetFrustum ( ) ) ;
}
MDLCACHE_CRITICAL_SECTION ( ) ;
engine - > Sound_ExtraUpdate ( ) ; // Make sure sound doesn't stutter
m_DrawFlags | = DF_SSAO_DEPTH_PASS ;
{
VPROF_BUDGET ( " DrawWorld " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
DrawWorld ( 0.0f ) ;
}
// Draw opaque and translucent renderables with appropriate override materials
// OVERRIDE_SSAO_DEPTH_WRITE is OK with a NULL material pointer
modelrender - > ForcedMaterialOverride ( NULL , OVERRIDE_SSAO_DEPTH_WRITE ) ;
{
VPROF_BUDGET ( " DrawOpaqueRenderables " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
DrawOpaqueRenderables ( DEPTH_MODE_SSA0 ) ;
}
#if 0
if ( m_bRenderFlashlightDepthTranslucents | | r_flashlightdepth_drawtranslucents . GetBool ( ) )
{
VPROF_BUDGET ( " DrawTranslucentRenderables " , VPROF_BUDGETGROUP_SHADOW_DEPTH_TEXTURING ) ;
DrawTranslucentRenderables ( false , true ) ;
}
# endif
modelrender - > ForcedMaterialOverride ( 0 ) ;
m_DrawFlags & = ~ DF_SSAO_DEPTH_PASS ;
pRenderContext . GetFrom ( materials ) ;
if ( IsX360 ( ) )
{
//Resolve() the depth texture here. Before the pop so the copy will recognize that the resolutions are the same
pRenderContext - > CopyRenderTargetToTextureEx ( NULL , - 1 , NULL , NULL ) ;
}
render - > PopView ( GetFrustum ( ) ) ;
# if defined( _X360 )
pRenderContext - > PopVertexShaderGPRAllocation ( ) ;
# endif
pRenderContext . SafeRelease ( ) ;
g_CurrentViewID = savedViewID ;
# endif
}
void CBaseWorldView : : DrawDepthOfField ( )
{
if ( ! g_pMaterialSystemHardwareConfig - > SupportsPixelShaders_2_0 ( ) )
{
return ;
}
CMatRenderContextPtr pRenderContext ( materials ) ;
ITexture * pSmallFB0 = materials - > FindTexture ( " _rt_smallfb0 " , TEXTURE_GROUP_RENDER_TARGET ) ;
ITexture * pSmallFB1 = materials - > FindTexture ( " _rt_smallfb1 " , TEXTURE_GROUP_RENDER_TARGET ) ;
Rect_t DestRect ;
int w = pSmallFB0 - > GetActualWidth ( ) ;
int h = pSmallFB0 - > GetActualHeight ( ) ;
DestRect . x = 0 ;
DestRect . y = 0 ;
DestRect . width = w ;
DestRect . height = h ;
pRenderContext - > CopyRenderTargetToTextureEx ( pSmallFB0 , 0 , NULL , & DestRect ) ;
IMaterial * pPyroBlurXMaterial = materials - > FindMaterial ( " dev/pyro_blur_filter_x " , TEXTURE_GROUP_OTHER ) ;
IMaterial * pPyroBlurYMaterial = materials - > FindMaterial ( " dev/pyro_blur_filter_y " , TEXTURE_GROUP_OTHER ) ;
pRenderContext - > PushRenderTargetAndViewport ( pSmallFB1 , 0 , 0 , w , h ) ;
pRenderContext - > DrawScreenSpaceRectangle ( pPyroBlurYMaterial , 0 , 0 , w , h , 0 , 0 , w - 1 , h - 1 , w , h ) ;
pRenderContext - > PopRenderTargetAndViewport ( ) ;
pRenderContext - > PushRenderTargetAndViewport ( pSmallFB0 , 0 , 0 , w , h ) ;
pRenderContext - > DrawScreenSpaceRectangle ( pPyroBlurXMaterial , 0 , 0 , w , h , 0 , 0 , w - 1 , h - 1 , w , h ) ;
pRenderContext - > PopRenderTargetAndViewport ( ) ;
IMaterial * pPyroDepthOfFieldMaterial = materials - > FindMaterial ( " dev/pyro_dof " , TEXTURE_GROUP_OTHER ) ;
pRenderContext - > DrawScreenSpaceRectangle ( pPyroDepthOfFieldMaterial , x , y , width , height , 0 , 0 , width - 1 , height - 1 , width , height ) ;
}
//-----------------------------------------------------------------------------
// Draws the scene when there's no water or only cheap water
//-----------------------------------------------------------------------------
void CSimpleWorldView : : Setup ( const CViewSetup & view , int nClearFlags , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo , ViewCustomVisibility_t * pCustomVisibility )
{
BaseClass : : Setup ( view ) ;
m_ClearFlags = nClearFlags ;
m_DrawFlags = DF_DRAW_ENTITITES ;
if ( ! waterInfo . m_bOpaqueWater )
{
m_DrawFlags | = DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER ;
}
else
{
bool bViewIntersectsWater = DoesViewPlaneIntersectWater ( fogInfo . m_flWaterHeight , fogInfo . m_nVisibleFogVolume ) ;
if ( bViewIntersectsWater )
{
// have to draw both sides if we can see both.
m_DrawFlags | = DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER ;
}
else if ( fogInfo . m_bEyeInFogVolume )
{
m_DrawFlags | = DF_RENDER_UNDERWATER ;
}
else
{
m_DrawFlags | = DF_RENDER_ABOVEWATER ;
}
}
if ( waterInfo . m_bDrawWaterSurface )
{
m_DrawFlags | = DF_RENDER_WATER ;
}
if ( ! fogInfo . m_bEyeInFogVolume & & bDrawSkybox )
{
m_DrawFlags | = DF_DRAWSKYBOX ;
}
m_pCustomVisibility = pCustomVisibility ;
m_fogInfo = fogInfo ;
}
//-----------------------------------------------------------------------------
// Draws the scene when there's no water or only cheap water
//-----------------------------------------------------------------------------
void CSimpleWorldView : : Draw ( )
{
VPROF ( " CViewRender::ViewDrawScene_NoWater " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
PIXEVENT ( pRenderContext , " CSimpleWorldView::Draw " ) ;
# if defined( _X360 )
pRenderContext - > PushVertexShaderGPRAllocation ( 32 ) ; //lean toward pixel shader threads
# endif
pRenderContext . SafeRelease ( ) ;
DrawSetup ( 0 , m_DrawFlags , 0 ) ;
if ( ! m_fogInfo . m_bEyeInFogVolume )
{
EnableWorldFog ( ) ;
}
else
{
m_ClearFlags | = VIEW_CLEAR_COLOR ;
SetFogVolumeState ( m_fogInfo , false ) ;
pRenderContext . GetFrom ( materials ) ;
unsigned char ucFogColor [ 3 ] ;
pRenderContext - > GetFogColor ( ucFogColor ) ;
pRenderContext - > ClearColor4ub ( ucFogColor [ 0 ] , ucFogColor [ 1 ] , ucFogColor [ 2 ] , 255 ) ;
}
pRenderContext . SafeRelease ( ) ;
DrawExecute ( 0 , CurrentViewID ( ) , 0 ) ;
pRenderContext . GetFrom ( materials ) ;
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
# if defined( _X360 )
pRenderContext - > PopVertexShaderGPRAllocation ( ) ;
# endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CBaseWaterView : : CalcWaterEyeAdjustments ( const VisibleFogVolumeInfo_t & fogInfo ,
float & newWaterHeight , float & waterZAdjust , bool bSoftwareUserClipPlane )
{
if ( ! bSoftwareUserClipPlane )
{
newWaterHeight = fogInfo . m_flWaterHeight ;
waterZAdjust = 0.0f ;
return ;
}
newWaterHeight = fogInfo . m_flWaterHeight ;
float eyeToWaterZDelta = origin [ 2 ] - fogInfo . m_flWaterHeight ;
float epsilon = r_eyewaterepsilon . GetFloat ( ) ;
waterZAdjust = 0.0f ;
if ( fabs ( eyeToWaterZDelta ) < epsilon )
{
if ( eyeToWaterZDelta > 0 )
{
newWaterHeight = origin [ 2 ] - epsilon ;
}
else
{
newWaterHeight = origin [ 2 ] + epsilon ;
}
waterZAdjust = newWaterHeight - fogInfo . m_flWaterHeight ;
}
// Warning( "view.origin[2]: %f newWaterHeight: %f fogInfo.m_flWaterHeight: %f waterZAdjust: %f\n",
// ( float )view.origin[2], newWaterHeight, fogInfo.m_flWaterHeight, waterZAdjust );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CBaseWaterView : : CSoftwareIntersectionView : : Setup ( bool bAboveWater )
{
BaseClass : : Setup ( * GetOuter ( ) ) ;
m_DrawFlags = 0 ;
m_DrawFlags = ( bAboveWater ) ? DF_RENDER_UNDERWATER : DF_RENDER_ABOVEWATER ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CBaseWaterView : : CSoftwareIntersectionView : : Draw ( )
{
DrawSetup ( GetOuter ( ) - > m_waterHeight , m_DrawFlags , GetOuter ( ) - > m_waterZAdjust ) ;
DrawExecute ( GetOuter ( ) - > m_waterHeight , CurrentViewID ( ) , GetOuter ( ) - > m_waterZAdjust ) ;
}
//-----------------------------------------------------------------------------
// Draws the scene when the view point is above the level of the water
//-----------------------------------------------------------------------------
void CAboveWaterView : : Setup ( const CViewSetup & view , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo )
{
BaseClass : : Setup ( view ) ;
m_bSoftwareUserClipPlane = g_pMaterialSystemHardwareConfig - > UseFastClipping ( ) ;
CalcWaterEyeAdjustments ( fogInfo , m_waterHeight , m_waterZAdjust , m_bSoftwareUserClipPlane ) ;
// BROKEN STUFF!
if ( m_waterZAdjust = = 0.0f )
{
m_bSoftwareUserClipPlane = false ;
}
m_DrawFlags = DF_RENDER_ABOVEWATER | DF_DRAW_ENTITITES ;
m_ClearFlags = VIEW_CLEAR_DEPTH ;
# ifdef PORTAL
if ( g_pPortalRender - > ShouldObeyStencilForClears ( ) )
m_ClearFlags | = VIEW_CLEAR_OBEY_STENCIL ;
# endif
if ( bDrawSkybox )
{
m_DrawFlags | = DF_DRAWSKYBOX ;
}
if ( waterInfo . m_bDrawWaterSurface )
{
m_DrawFlags | = DF_RENDER_WATER ;
}
if ( ! waterInfo . m_bRefract & & ! waterInfo . m_bOpaqueWater )
{
m_DrawFlags | = DF_RENDER_UNDERWATER ;
}
m_fogInfo = fogInfo ;
m_waterInfo = waterInfo ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : Draw ( )
{
VPROF ( " CViewRender::ViewDrawScene_EyeAboveWater " ) ;
// eye is outside of water
CMatRenderContextPtr pRenderContext ( materials ) ;
// render the reflection
if ( m_waterInfo . m_bReflect )
{
m_ReflectionView . Setup ( m_waterInfo . m_bReflectEntities ) ;
m_pMainView - > AddViewToScene ( & m_ReflectionView ) ;
}
bool bViewIntersectsWater = false ;
// render refraction
if ( m_waterInfo . m_bRefract )
{
m_RefractionView . Setup ( ) ;
m_pMainView - > AddViewToScene ( & m_RefractionView ) ;
if ( ! m_bSoftwareUserClipPlane )
{
bViewIntersectsWater = DoesViewPlaneIntersectWater ( m_fogInfo . m_flWaterHeight , m_fogInfo . m_nVisibleFogVolume ) ;
}
}
else if ( ! ( m_DrawFlags & DF_DRAWSKYBOX ) )
{
m_ClearFlags | = VIEW_CLEAR_COLOR ;
}
# ifdef PORTAL
if ( g_pPortalRender - > ShouldObeyStencilForClears ( ) )
m_ClearFlags | = VIEW_CLEAR_OBEY_STENCIL ;
# endif
// NOTE!!!!! YOU CAN ONLY DO THIS IF YOU HAVE HARDWARE USER CLIP PLANES!!!!!!
bool bHardwareUserClipPlanes = ! g_pMaterialSystemHardwareConfig - > UseFastClipping ( ) ;
if ( bViewIntersectsWater & & bHardwareUserClipPlanes )
{
// This is necessary to keep the non-water fogged world from drawing underwater in
// the case where we want to partially see into the water.
m_DrawFlags | = DF_CLIP_Z | DF_CLIP_BELOW ;
}
// render the world
DrawSetup ( m_waterHeight , m_DrawFlags , m_waterZAdjust ) ;
EnableWorldFog ( ) ;
DrawExecute ( m_waterHeight , CurrentViewID ( ) , m_waterZAdjust ) ;
if ( m_waterInfo . m_bRefract )
{
if ( m_bSoftwareUserClipPlane )
{
m_SoftwareIntersectionView . Setup ( true ) ;
m_SoftwareIntersectionView . Draw ( ) ;
}
else if ( bViewIntersectsWater )
{
m_IntersectionView . Setup ( ) ;
m_pMainView - > AddViewToScene ( & m_IntersectionView ) ;
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : CReflectionView : : Setup ( bool bReflectEntities )
{
BaseClass : : Setup ( * GetOuter ( ) ) ;
m_ClearFlags = VIEW_CLEAR_DEPTH ;
// NOTE: Clearing the color is unnecessary since we're drawing the skybox
// and dest-alpha is never used in the reflection
m_DrawFlags = DF_RENDER_REFLECTION | DF_CLIP_Z | DF_CLIP_BELOW |
DF_RENDER_ABOVEWATER ;
// NOTE: This will cause us to draw the 2d skybox in the reflection
// (which we want to do instead of drawing the 3d skybox)
m_DrawFlags | = DF_DRAWSKYBOX ;
if ( bReflectEntities )
{
m_DrawFlags | = DF_DRAW_ENTITITES ;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : CReflectionView : : Draw ( )
{
# ifdef PORTAL
g_pPortalRender - > WaterRenderingHandler_PreReflection ( ) ;
# endif
// Store off view origin and angles and set the new view
int nSaveViewID = CurrentViewID ( ) ;
SetupCurrentView ( origin , angles , VIEW_REFLECTION ) ;
// Disable occlusion visualization in reflection
bool bVisOcclusion = r_visocclusion . GetInt ( ) ;
r_visocclusion . SetValue ( 0 ) ;
DrawSetup ( GetOuter ( ) - > m_fogInfo . m_flWaterHeight , m_DrawFlags , 0.0f , GetOuter ( ) - > m_fogInfo . m_nVisibleFogVolumeLeaf ) ;
EnableWorldFog ( ) ;
DrawExecute ( GetOuter ( ) - > m_fogInfo . m_flWaterHeight , VIEW_REFLECTION , 0.0f ) ;
r_visocclusion . SetValue ( bVisOcclusion ) ;
# ifdef PORTAL
// deal with stencil
g_pPortalRender - > WaterRenderingHandler_PostReflection ( ) ;
# endif
// finish off the view and restore the previous view.
SetupCurrentView ( origin , angles , ( view_id_t ) nSaveViewID ) ;
// This is here for multithreading
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > Flush ( ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : CRefractionView : : Setup ( )
{
BaseClass : : Setup ( * GetOuter ( ) ) ;
m_ClearFlags = VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH ;
m_DrawFlags = DF_RENDER_REFRACTION | DF_CLIP_Z |
DF_RENDER_UNDERWATER | DF_FUDGE_UP |
DF_DRAW_ENTITITES ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : CRefractionView : : Draw ( )
{
# ifdef PORTAL
g_pPortalRender - > WaterRenderingHandler_PreRefraction ( ) ;
# endif
// Store off view origin and angles and set the new view
int nSaveViewID = CurrentViewID ( ) ;
SetupCurrentView ( origin , angles , VIEW_REFRACTION ) ;
DrawSetup ( GetOuter ( ) - > m_waterHeight , m_DrawFlags , GetOuter ( ) - > m_waterZAdjust ) ;
SetFogVolumeState ( GetOuter ( ) - > m_fogInfo , true ) ;
SetClearColorToFogColor ( ) ;
DrawExecute ( GetOuter ( ) - > m_waterHeight , VIEW_REFRACTION , GetOuter ( ) - > m_waterZAdjust ) ;
# ifdef PORTAL
// deal with stencil
g_pPortalRender - > WaterRenderingHandler_PostRefraction ( ) ;
# endif
// finish off the view. restore the previous view.
SetupCurrentView ( origin , angles , ( view_id_t ) nSaveViewID ) ;
// This is here for multithreading
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
pRenderContext - > Flush ( ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : CIntersectionView : : Setup ( )
{
BaseClass : : Setup ( * GetOuter ( ) ) ;
m_DrawFlags = DF_RENDER_UNDERWATER | DF_CLIP_Z | DF_DRAW_ENTITITES ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAboveWaterView : : CIntersectionView : : Draw ( )
{
DrawSetup ( GetOuter ( ) - > m_fogInfo . m_flWaterHeight , m_DrawFlags , 0 ) ;
SetFogVolumeState ( GetOuter ( ) - > m_fogInfo , true ) ;
SetClearColorToFogColor ( ) ;
DrawExecute ( GetOuter ( ) - > m_fogInfo . m_flWaterHeight , VIEW_NONE , 0 ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
}
//-----------------------------------------------------------------------------
// Draws the scene when the view point is under the level of the water
//-----------------------------------------------------------------------------
void CUnderWaterView : : Setup ( const CViewSetup & view , bool bDrawSkybox , const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo )
{
BaseClass : : Setup ( view ) ;
m_bSoftwareUserClipPlane = g_pMaterialSystemHardwareConfig - > UseFastClipping ( ) ;
CalcWaterEyeAdjustments ( fogInfo , m_waterHeight , m_waterZAdjust , m_bSoftwareUserClipPlane ) ;
IMaterial * pWaterMaterial = fogInfo . m_pFogVolumeMaterial ;
if ( engine - > GetDXSupportLevel ( ) > = 90 ) // screen voerlays underwater are a dx9 feature
{
IMaterialVar * pScreenOverlayVar = pWaterMaterial - > FindVar ( " $underwateroverlay " , NULL , false ) ;
if ( pScreenOverlayVar & & ( pScreenOverlayVar - > IsDefined ( ) ) )
{
char const * pOverlayName = pScreenOverlayVar - > GetStringValue ( ) ;
if ( pOverlayName [ 0 ] ! = ' 0 ' ) // fixme!!!
{
IMaterial * pOverlayMaterial = materials - > FindMaterial ( pOverlayName , TEXTURE_GROUP_OTHER ) ;
m_pMainView - > SetWaterOverlayMaterial ( pOverlayMaterial ) ;
}
}
}
// NOTE: We're not drawing the 2d skybox under water since it's assumed to not be visible.
// render the world underwater
// Clear the color to get the appropriate underwater fog color
m_DrawFlags = DF_FUDGE_UP | DF_RENDER_UNDERWATER | DF_DRAW_ENTITITES ;
m_ClearFlags = VIEW_CLEAR_DEPTH ;
if ( ! m_bSoftwareUserClipPlane )
{
m_DrawFlags | = DF_CLIP_Z ;
}
if ( waterInfo . m_bDrawWaterSurface )
{
m_DrawFlags | = DF_RENDER_WATER ;
}
if ( ! waterInfo . m_bRefract & & ! waterInfo . m_bOpaqueWater )
{
m_DrawFlags | = DF_RENDER_ABOVEWATER ;
}
m_fogInfo = fogInfo ;
m_waterInfo = waterInfo ;
m_bDrawSkybox = bDrawSkybox ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CUnderWaterView : : Draw ( )
{
// FIXME: The 3d skybox shouldn't be drawn when the eye is under water
VPROF ( " CViewRender::ViewDrawScene_EyeUnderWater " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
// render refraction (out of water)
if ( m_waterInfo . m_bRefract )
{
m_RefractionView . Setup ( ) ;
m_pMainView - > AddViewToScene ( & m_RefractionView ) ;
}
if ( ! m_waterInfo . m_bRefract )
{
SetFogVolumeState ( m_fogInfo , true ) ;
unsigned char ucFogColor [ 3 ] ;
pRenderContext - > GetFogColor ( ucFogColor ) ;
pRenderContext - > ClearColor4ub ( ucFogColor [ 0 ] , ucFogColor [ 1 ] , ucFogColor [ 2 ] , 255 ) ;
}
DrawSetup ( m_waterHeight , m_DrawFlags , m_waterZAdjust ) ;
SetFogVolumeState ( m_fogInfo , false ) ;
DrawExecute ( m_waterHeight , CurrentViewID ( ) , m_waterZAdjust ) ;
m_ClearFlags = 0 ;
if ( m_waterZAdjust ! = 0.0f & & m_bSoftwareUserClipPlane & & m_waterInfo . m_bRefract )
{
m_SoftwareIntersectionView . Setup ( false ) ;
m_SoftwareIntersectionView . Draw ( ) ;
}
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CUnderWaterView : : CRefractionView : : Setup ( )
{
BaseClass : : Setup ( * GetOuter ( ) ) ;
// NOTE: Refraction renders into the back buffer, over the top of the 3D skybox
// It is then blitted out into the refraction target. This is so that
// we only have to set up 3d sky vis once, and only render it once also!
m_DrawFlags = DF_CLIP_Z |
DF_CLIP_BELOW | DF_RENDER_ABOVEWATER |
DF_DRAW_ENTITITES ;
m_ClearFlags = VIEW_CLEAR_DEPTH ;
if ( GetOuter ( ) - > m_bDrawSkybox )
{
m_ClearFlags | = VIEW_CLEAR_COLOR ;
m_DrawFlags | = DF_DRAWSKYBOX | DF_CLIP_SKYBOX ;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CUnderWaterView : : CRefractionView : : Draw ( )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
SetFogVolumeState ( GetOuter ( ) - > m_fogInfo , true ) ;
unsigned char ucFogColor [ 3 ] ;
pRenderContext - > GetFogColor ( ucFogColor ) ;
pRenderContext - > ClearColor4ub ( ucFogColor [ 0 ] , ucFogColor [ 1 ] , ucFogColor [ 2 ] , 255 ) ;
DrawSetup ( GetOuter ( ) - > m_waterHeight , m_DrawFlags , GetOuter ( ) - > m_waterZAdjust ) ;
EnableWorldFog ( ) ;
DrawExecute ( GetOuter ( ) - > m_waterHeight , VIEW_REFRACTION , GetOuter ( ) - > m_waterZAdjust ) ;
Rect_t srcRect ;
srcRect . x = x ;
srcRect . y = y ;
srcRect . width = width ;
srcRect . height = height ;
// Optionally write the rendered image to a debug texture
if ( g_bDumpRenderTargets )
{
DumpTGAofRenderTarget ( width , height , " WaterRefract " ) ;
}
ITexture * pTexture = GetWaterRefractionTexture ( ) ;
pRenderContext - > CopyRenderTargetToTextureEx ( pTexture , 0 , & srcRect , NULL ) ;
}
//-----------------------------------------------------------------------------
//
// Reflective glass view starts here
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Draws the scene when the view contains reflective glass
//-----------------------------------------------------------------------------
void CReflectiveGlassView : : Setup ( const CViewSetup & view , int nClearFlags , bool bDrawSkybox ,
const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo , const cplane_t & reflectionPlane )
{
BaseClass : : Setup ( view , nClearFlags , bDrawSkybox , fogInfo , waterInfo , NULL ) ;
m_ReflectionPlane = reflectionPlane ;
}
bool CReflectiveGlassView : : AdjustView ( float flWaterHeight )
{
ITexture * pTexture = GetWaterReflectionTexture ( ) ;
// Use the aspect ratio of the main view! So, don't recompute it here
x = y = 0 ;
width = pTexture - > GetActualWidth ( ) ;
height = pTexture - > GetActualHeight ( ) ;
// Reflect the camera origin + vectors around the reflection plane
float flDist = DotProduct ( origin , m_ReflectionPlane . normal ) - m_ReflectionPlane . dist ;
VectorMA ( origin , - 2.0f * flDist , m_ReflectionPlane . normal , origin ) ;
Vector vecForward , vecUp ;
AngleVectors ( angles , & vecForward , NULL , & vecUp ) ;
float flDot = DotProduct ( vecForward , m_ReflectionPlane . normal ) ;
VectorMA ( vecForward , - 2.0f * flDot , m_ReflectionPlane . normal , vecForward ) ;
flDot = DotProduct ( vecUp , m_ReflectionPlane . normal ) ;
VectorMA ( vecUp , - 2.0f * flDot , m_ReflectionPlane . normal , vecUp ) ;
VectorAngles ( vecForward , vecUp , angles ) ;
return true ;
}
void CReflectiveGlassView : : PushView ( float waterHeight )
{
render - > Push3DView ( * this , m_ClearFlags , GetWaterReflectionTexture ( ) , GetFrustum ( ) ) ;
Vector4D plane ;
VectorCopy ( m_ReflectionPlane . normal , plane . AsVector3D ( ) ) ;
plane . w = m_ReflectionPlane . dist + 0.1f ;
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > PushCustomClipPlane ( plane . Base ( ) ) ;
}
void CReflectiveGlassView : : PopView ( )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > PopCustomClipPlane ( ) ;
render - > PopView ( GetFrustum ( ) ) ;
}
//-----------------------------------------------------------------------------
// Renders reflective or refractive parts of glass
//-----------------------------------------------------------------------------
void CReflectiveGlassView : : Draw ( )
{
VPROF ( " CReflectiveGlassView::Draw " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
PIXEVENT ( pRenderContext , " CReflectiveGlassView::Draw " ) ;
// Disable occlusion visualization in reflection
bool bVisOcclusion = r_visocclusion . GetInt ( ) ;
r_visocclusion . SetValue ( 0 ) ;
BaseClass : : Draw ( ) ;
r_visocclusion . SetValue ( bVisOcclusion ) ;
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
pRenderContext - > Flush ( ) ;
}
//-----------------------------------------------------------------------------
// Draws the scene when the view contains reflective glass
//-----------------------------------------------------------------------------
void CRefractiveGlassView : : Setup ( const CViewSetup & view , int nClearFlags , bool bDrawSkybox ,
const VisibleFogVolumeInfo_t & fogInfo , const WaterRenderInfo_t & waterInfo , const cplane_t & reflectionPlane )
{
BaseClass : : Setup ( view , nClearFlags , bDrawSkybox , fogInfo , waterInfo , NULL ) ;
m_ReflectionPlane = reflectionPlane ;
}
bool CRefractiveGlassView : : AdjustView ( float flWaterHeight )
{
ITexture * pTexture = GetWaterRefractionTexture ( ) ;
// Use the aspect ratio of the main view! So, don't recompute it here
x = y = 0 ;
width = pTexture - > GetActualWidth ( ) ;
height = pTexture - > GetActualHeight ( ) ;
return true ;
}
void CRefractiveGlassView : : PushView ( float waterHeight )
{
render - > Push3DView ( * this , m_ClearFlags , GetWaterRefractionTexture ( ) , GetFrustum ( ) ) ;
Vector4D plane ;
VectorMultiply ( m_ReflectionPlane . normal , - 1 , plane . AsVector3D ( ) ) ;
plane . w = - m_ReflectionPlane . dist + 0.1f ;
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > PushCustomClipPlane ( plane . Base ( ) ) ;
}
void CRefractiveGlassView : : PopView ( )
{
CMatRenderContextPtr pRenderContext ( materials ) ;
pRenderContext - > PopCustomClipPlane ( ) ;
render - > PopView ( GetFrustum ( ) ) ;
}
//-----------------------------------------------------------------------------
// Renders reflective or refractive parts of glass
//-----------------------------------------------------------------------------
void CRefractiveGlassView : : Draw ( )
{
VPROF ( " CRefractiveGlassView::Draw " ) ;
CMatRenderContextPtr pRenderContext ( materials ) ;
PIXEVENT ( pRenderContext , " CRefractiveGlassView::Draw " ) ;
BaseClass : : Draw ( ) ;
pRenderContext - > ClearColor4ub ( 0 , 0 , 0 , 255 ) ;
pRenderContext - > Flush ( ) ;
}