mirror of
https://github.com/ValveSoftware/source-sdk-2013.git
synced 2025-06-30 06:29:27 +03:00
beaae8ac45
* Adds support for Visual Studio 2012 and 2013 * VR Mode: . Switches from headtrack.dll to sourcevr.dll . Improved readability of the UI in VR . Removed the IPD calibration tool. TF2 will now obey the Oculus configuration file. Use the Oculus calibration tool in your SDK or install and run "OpenVR" under Tools in Steam to calibrate your IPD. . Added dropdown to enable VR mode in the Video options. Removed the -vr command line option. . Added the ability to switch in and out of VR mode without quitting the game . By default VR mode will run full screen. To switch back to a borderless window set the vr_force_windowed convar. . Added support for VR mode on Linux * Many assorted bug fixes and other changes from Team Fortress in various shared files
6260 lines
196 KiB
C++
6260 lines
196 KiB
C++
//========= 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] = { pFogParams->colorPrimaryLerpTo.GetR(), pFogParams->colorPrimaryLerpTo.GetG(), pFogParams->colorPrimaryLerpTo.GetB() };
|
|
float flSecondaryColorLerp[3] = { pFogParams->colorSecondaryLerpTo.GetR(), pFogParams->colorSecondaryLerpTo.GetG(), 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] = { pFogParams->colorPrimary.GetR(), pFogParams->colorPrimary.GetG(), pFogParams->colorPrimary.GetB() };
|
|
float flSecondaryColor[3] = { pFogParams->colorSecondary.GetR(), pFogParams->colorSecondary.GetG(), 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() )
|
|
{
|
|
vgui::surface()->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\nforcecheap: %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;
|
|
int iRecursionLevel = g_pPortalRender->GetViewRecursionLevel();
|
|
Assert( iRecursionLevel > 0 );
|
|
|
|
//get references to reflection textures
|
|
CTextureReference pPrimaryWaterReflectionTexture;
|
|
pPrimaryWaterReflectionTexture.Init( GetWaterReflectionTexture() );
|
|
CTextureReference pReplacementWaterReflectionTexture;
|
|
pReplacementWaterReflectionTexture.Init( portalrendertargets->GetWaterReflectionTextureForStencilDepth( iRecursionLevel ) );
|
|
|
|
//get references to refraction textures
|
|
CTextureReference pPrimaryWaterRefractionTexture;
|
|
pPrimaryWaterRefractionTexture.Init( GetWaterRefractionTexture() );
|
|
CTextureReference pReplacementWaterRefractionTexture;
|
|
pReplacementWaterRefractionTexture.Init( portalrendertargets->GetWaterRefractionTextureForStencilDepth( iRecursionLevel ) );
|
|
|
|
|
|
//swap texture contents for the primary render targets with those we set aside for this recursion level
|
|
if( pReplacementWaterReflectionTexture != NULL )
|
|
pPrimaryWaterReflectionTexture->SwapContents( pReplacementWaterReflectionTexture );
|
|
|
|
if( pReplacementWaterRefractionTexture != NULL )
|
|
pPrimaryWaterRefractionTexture->SwapContents( pReplacementWaterRefractionTexture );
|
|
|
|
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 #
|
|
|
|
|
|
//swap back the water render targets
|
|
if( pReplacementWaterReflectionTexture != NULL )
|
|
pPrimaryWaterReflectionTexture->SwapContents( pReplacementWaterReflectionTexture );
|
|
|
|
if( pReplacementWaterRefractionTexture != NULL )
|
|
pPrimaryWaterRefractionTexture->SwapContents( pReplacementWaterRefractionTexture );
|
|
}
|
|
|
|
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 )
|
|
NULL;
|
|
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 )
|
|
{
|
|
if ( bDrawopaquestaticpropslast )
|
|
{
|
|
DrawOpaqueRenderables_Range( pEnts[bucket][0], pEnts[bucket][1], DepthMode );
|
|
DrawOpaqueRenderables_DrawStaticProps( pProps[bucket][0], pProps[bucket][1], DepthMode );
|
|
}
|
|
else
|
|
{
|
|
DrawOpaqueRenderables_Range( pEnts[bucket][0], pEnts[bucket][1], DepthMode );
|
|
DrawOpaqueRenderables_DrawStaticProps( pProps[bucket][0], pProps[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();
|
|
}
|