1262 lines
38 KiB
C++
1262 lines
38 KiB
C++
|
//===== Copyright (c) Valve Corporation, All rights reserved. ======//
|
||
|
|
//
|
||
|
|
// Purpose:
|
||
|
|
//
|
||
|
|
// $NoKeywords: $
|
||
|
|
//
|
||
|
|
//==================================================================//
|
||
|
|
|
||
|
|
|
||
|
|
#include "render_pch.h"
|
||
|
|
#include "client.h"
|
||
|
|
#include "sound.h"
|
||
|
|
#include "debug_leafvis.h"
|
||
|
|
#include "cdll_int.h"
|
||
|
|
#include "enginestats.h"
|
||
|
|
#include "ivrenderview.h"
|
||
|
|
#include "studio.h"
|
||
|
|
#include "l_studio.h"
|
||
|
|
#include "r_areaportal.h"
|
||
|
|
#include "materialsystem/materialsystem_config.h"
|
||
|
|
#include "materialsystem/itexture.h"
|
||
|
|
#include "cdll_engine_int.h"
|
||
|
|
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
||
|
|
#include "istudiorender.h"
|
||
|
|
#include "staticpropmgr.h"
|
||
|
|
#include "tier0/vprof.h"
|
||
|
|
#include "IOcclusionSystem.h"
|
||
|
|
#include "con_nprint.h"
|
||
|
|
#include "debugoverlay.h"
|
||
|
|
#include "demo.h"
|
||
|
|
#include "ivideomode.h"
|
||
|
|
#include "sys_dll.h"
|
||
|
|
#include "collisionutils.h"
|
||
|
|
#include "tier1/utlstack.h"
|
||
|
|
#include "r_decal.h"
|
||
|
|
#include "cl_main.h"
|
||
|
|
#include "paint.h"
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include "tier0/memdbgon.h"
|
||
|
|
|
||
|
|
#ifndef _X360
|
||
|
|
extern ConVar r_waterforceexpensive;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ConVar r_aspectratio( "r_aspectratio", "0" );
|
||
|
|
ConVar r_dynamiclighting( "r_dynamiclighting", "1", FCVAR_CHEAT );
|
||
|
|
extern ConVar building_cubemaps;
|
||
|
|
extern float scr_demo_override_fov;
|
||
|
|
|
||
|
|
extern colorVec R_LightPoint (Vector& p);
|
||
|
|
|
||
|
|
CEngineStats g_EngineStats;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// view origin
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
extern Vector g_CurrentViewOrigin, g_CurrentViewForward, g_CurrentViewRight, g_CurrentViewUp;
|
||
|
|
extern Vector g_MainViewOrigin[ MAX_SPLITSCREEN_CLIENTS ];
|
||
|
|
extern Vector g_MainViewForward[ MAX_SPLITSCREEN_CLIENTS ];
|
||
|
|
extern Vector g_MainViewRight[ MAX_SPLITSCREEN_CLIENTS ];
|
||
|
|
extern Vector g_MainViewUp[ MAX_SPLITSCREEN_CLIENTS ];
|
||
|
|
bool g_bCanAccessCurrentView = false;
|
||
|
|
|
||
|
|
int d_lightstyleframe[256];
|
||
|
|
CUtlVector<LightmapUpdateInfo_t> g_LightmapUpdateList;
|
||
|
|
CUtlVector<LightmapTransformInfo_t> g_LightmapTransformList;
|
||
|
|
|
||
|
|
void ProjectPointOnPlane( Vector& dst, const Vector& p, const Vector& normal )
|
||
|
|
{
|
||
|
|
float d;
|
||
|
|
Vector n;
|
||
|
|
float inv_denom;
|
||
|
|
|
||
|
|
inv_denom = 1.0F / DotProduct( normal, normal );
|
||
|
|
|
||
|
|
d = DotProduct( normal, p ) * inv_denom;
|
||
|
|
|
||
|
|
n[0] = normal[0] * inv_denom;
|
||
|
|
n[1] = normal[1] * inv_denom;
|
||
|
|
n[2] = normal[2] * inv_denom;
|
||
|
|
|
||
|
|
dst[0] = p[0] - d * n[0];
|
||
|
|
dst[1] = p[1] - d * n[1];
|
||
|
|
dst[2] = p[2] - d * n[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
** assumes "src" is normalized
|
||
|
|
*/
|
||
|
|
void PerpendicularVector( Vector& dst, const Vector& src )
|
||
|
|
{
|
||
|
|
int pos;
|
||
|
|
int i;
|
||
|
|
float minelem = 1.0F;
|
||
|
|
Vector tempvec;
|
||
|
|
|
||
|
|
/*
|
||
|
|
** find the smallest magnitude axially aligned vector
|
||
|
|
*/
|
||
|
|
for ( pos = 0, i = 0; i < 3; i++ )
|
||
|
|
{
|
||
|
|
if ( fabs( src[i] ) < minelem )
|
||
|
|
{
|
||
|
|
pos = i;
|
||
|
|
minelem = fabs( src[i] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
|
||
|
|
tempvec[pos] = 1.0F;
|
||
|
|
|
||
|
|
/*
|
||
|
|
** project the point onto the plane defined by src
|
||
|
|
*/
|
||
|
|
ProjectPointOnPlane( dst, tempvec, src );
|
||
|
|
|
||
|
|
/*
|
||
|
|
** normalize the result
|
||
|
|
*/
|
||
|
|
VectorNormalize( dst );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Returns the PHYSICAL aspect ratio of the screen (not the pixel aspect ratio)
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
float GetScreenAspect( int viewportWidth, int viewportHeight )
|
||
|
|
{
|
||
|
|
// use the override if set
|
||
|
|
if ( r_aspectratio.GetFloat() > 0.0f )
|
||
|
|
return r_aspectratio.GetFloat();
|
||
|
|
|
||
|
|
const AspectRatioInfo_t &aspectRatioInfo = materials->GetAspectRatioInfo();
|
||
|
|
|
||
|
|
// just use the viewport size, but we have to convert from pixels to real-world "size".
|
||
|
|
return ( viewportHeight != 0 ) ? ( aspectRatioInfo.m_flFrameBuffertoPhysicalScalar * ( ( float )viewportWidth / ( float )viewportHeight ) ) : 1.0f;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
====================
|
||
|
|
CalcFov
|
||
|
|
====================
|
||
|
|
*/
|
||
|
|
void R_DrawScreenRect( float left, float top, float right, float bottom )
|
||
|
|
{
|
||
|
|
CMatRenderContextPtr pRenderContext( materials );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
|
||
|
|
|
||
|
|
IMaterial *pMaterial = materials->FindMaterial( "debug/debugportals", TEXTURE_GROUP_OTHER );
|
||
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
|
||
|
|
|
||
|
|
CMeshBuilder builder;
|
||
|
|
builder.Begin( pMesh, MATERIAL_LINE_LOOP, 4 );
|
||
|
|
|
||
|
|
Vector v1( left, bottom, 0.5 );
|
||
|
|
Vector v2( left, top, 0.5 );
|
||
|
|
Vector v3( right, top, 0.5 );
|
||
|
|
Vector v4( right, bottom, 0.5 );
|
||
|
|
|
||
|
|
builder.Position3fv( v1.Base() ); builder.AdvanceVertex();
|
||
|
|
builder.Position3fv( v2.Base() ); builder.AdvanceVertex();
|
||
|
|
builder.Position3fv( v3.Base() ); builder.AdvanceVertex();
|
||
|
|
builder.Position3fv( v4.Base() ); builder.AdvanceVertex();
|
||
|
|
|
||
|
|
builder.End( false, true );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void R_DrawPortals()
|
||
|
|
{
|
||
|
|
// Draw the portals.
|
||
|
|
if( !r_DrawPortals.GetInt() )
|
||
|
|
return;
|
||
|
|
|
||
|
|
IMaterial *pMaterial = materials->FindMaterial( "debug/debugportals", TEXTURE_GROUP_OTHER );
|
||
|
|
CMatRenderContextPtr pRenderContext( materials );
|
||
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
|
||
|
|
|
||
|
|
worldbrushdata_t *pBrushData = host_state.worldbrush;
|
||
|
|
for( int i=0; i < pBrushData->m_nAreaPortals; i++ )
|
||
|
|
{
|
||
|
|
dareaportal_t *pAreaPortal = &pBrushData->m_pAreaPortals[i];
|
||
|
|
|
||
|
|
if( !R_IsAreaVisible( pAreaPortal->otherarea ) )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
CMeshBuilder builder;
|
||
|
|
builder.Begin( pMesh, MATERIAL_LINES, pAreaPortal->m_nClipPortalVerts );
|
||
|
|
|
||
|
|
for( int j=0; j < pAreaPortal->m_nClipPortalVerts; j++ )
|
||
|
|
{
|
||
|
|
unsigned short iVert;
|
||
|
|
|
||
|
|
iVert = pAreaPortal->m_FirstClipPortalVert + j;
|
||
|
|
builder.Position3f( VectorExpand( pBrushData->m_pClipPortalVerts[iVert] ) );
|
||
|
|
builder.Color4f( 0, 0, 0, 1 );
|
||
|
|
builder.AdvanceVertex();
|
||
|
|
|
||
|
|
iVert = pAreaPortal->m_FirstClipPortalVert + (j+1) % pAreaPortal->m_nClipPortalVerts;
|
||
|
|
builder.Position3f( VectorExpand( pBrushData->m_pClipPortalVerts[iVert] ) );
|
||
|
|
builder.Color4f( 0, 0, 0, 1 );
|
||
|
|
builder.AdvanceVertex();
|
||
|
|
}
|
||
|
|
|
||
|
|
builder.End( false, true );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Draw the clip rectangles.
|
||
|
|
for( int i=0; i < g_PortalRects.Count(); i++ )
|
||
|
|
{
|
||
|
|
CPortalRect *pRect = &g_PortalRects[i];
|
||
|
|
R_DrawScreenRect( pRect->left, pRect->top, pRect->right, pRect->bottom );
|
||
|
|
}
|
||
|
|
g_PortalRects.Purge();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Loose collection of functions related to rendering the world in a particular view
|
||
|
|
//
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
class CRender : public IRender
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
CRender();
|
||
|
|
|
||
|
|
void FrameBegin( void );
|
||
|
|
void FrameEnd( void );
|
||
|
|
|
||
|
|
void ViewSetupVis( bool novis, int numorigins, const Vector origin[] );
|
||
|
|
void ViewSetupVisEx( bool novis, int numorigins, const Vector origin[], unsigned int &returnFlags );
|
||
|
|
|
||
|
|
void ViewEnd( void );
|
||
|
|
|
||
|
|
void ViewDrawFade( byte *color, IMaterial* pMaterial, bool mapFullTextureToScreen = true );
|
||
|
|
|
||
|
|
IWorldRenderList * CreateWorldList();
|
||
|
|
#if defined(_PS3)
|
||
|
|
IWorldRenderList * CreateWorldList_PS3( int viewID );
|
||
|
|
void BuildWorldLists_PS3_Epilogue( IWorldRenderList *pList, WorldListInfo_t* pInfo, bool bShadowDepth );
|
||
|
|
int GetDrawFlags( void );
|
||
|
|
int GetBuildViewID( void );
|
||
|
|
bool IsSPUBuildWRJobsOn( void );
|
||
|
|
void CacheFrustumData( Frustum_t *pFrustum, Frustum_t *pAreaFrustum, void *pRenderAreaBits, int numArea, bool bViewerInSolidSpace );
|
||
|
|
#else
|
||
|
|
void BuildWorldLists_Epilogue( IWorldRenderList *pList, WorldListInfo_t* pInfo, bool bShadowDepth );
|
||
|
|
#endif
|
||
|
|
|
||
|
|
void BuildWorldLists( IWorldRenderList *pList, WorldListInfo_t* pInfo, int iForceViewLeaf, const VisOverrideData_t* pVisData, bool bShadowDepth, float *pWaterReflectionHeight );
|
||
|
|
void DrawWorldLists( IMatRenderContext *pRenderContext, IWorldRenderList *pList, unsigned long flags, float waterZAdjust );
|
||
|
|
|
||
|
|
void DrawSceneBegin( void );
|
||
|
|
void DrawSceneEnd( void );
|
||
|
|
|
||
|
|
// utility functions
|
||
|
|
void ExtractMatrices( void );
|
||
|
|
void ExtractFrustumPlanes( Frustum frustumPlanes );
|
||
|
|
void OrthoExtractFrustumPlanes( Frustum frustumPlanes );
|
||
|
|
void OverrideViewFrustum( Frustum custom );
|
||
|
|
|
||
|
|
void SetViewport( int x, int y, int w, int h );
|
||
|
|
// UNDONE: these are temporary functions that will end up on the other
|
||
|
|
// side of this interface
|
||
|
|
const Vector &ViewOrigin( ) { return CurrentView().origin; }
|
||
|
|
const QAngle &ViewAngles( ) { return CurrentView().angles; }
|
||
|
|
const CViewSetup &ViewGetCurrent( void ) { return CurrentView(); }
|
||
|
|
const VMatrix &ViewMatrix( void );
|
||
|
|
const VMatrix &WorldToScreenMatrix( void );
|
||
|
|
|
||
|
|
float GetFramerate( void ) { return m_framerate; }
|
||
|
|
virtual float GetZNear( void ) { return m_zNear; }
|
||
|
|
virtual float GetZFar( void ) { return m_zFar; }
|
||
|
|
|
||
|
|
// Query current fov and view model fov
|
||
|
|
float GetFov( void ) { return CurrentView().fov; };
|
||
|
|
float GetFovY( void ) { return m_yFOV; };
|
||
|
|
float GetFovViewmodel( void ) { return CurrentView().fovViewmodel; };
|
||
|
|
|
||
|
|
virtual bool ClipTransform( const Vector& point, Vector* pClip );
|
||
|
|
virtual bool ScreenTransform( const Vector& point, Vector* pScreen );
|
||
|
|
|
||
|
|
virtual void Push3DView( IMatRenderContext *pRenderContext, const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes );
|
||
|
|
virtual void Push3DView( IMatRenderContext *pRenderContext, const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes, ITexture* pDepthTexture );
|
||
|
|
virtual void Push2DView( IMatRenderContext *pRenderContext, const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes );
|
||
|
|
virtual void PopView( IMatRenderContext *pRenderContext, Frustum frustumPlanes );
|
||
|
|
virtual void SetMainView( const Vector &vecOrigin, const QAngle &angles );
|
||
|
|
|
||
|
|
virtual void UpdateBrushModelLightmap( model_t *model, IClientRenderable *Renderable );
|
||
|
|
virtual void BeginUpdateLightmaps( void );
|
||
|
|
virtual void EndUpdateLightmaps( void );
|
||
|
|
virtual bool InLightmapUpdate( void ) const;
|
||
|
|
|
||
|
|
private:
|
||
|
|
// Called when a particular view becomes active
|
||
|
|
void OnViewActive( Frustum frustumPlanes );
|
||
|
|
|
||
|
|
// Clear the view (assumes the render target has already been pushed)
|
||
|
|
void ClearView( IMatRenderContext *pRenderContext, CViewSetup &view, int nFlags, ITexture* pRenderTarget, ITexture* pDepthTexture = NULL );
|
||
|
|
|
||
|
|
const CViewSetup &CurrentView() const { return m_ViewStack.Top().m_View; }
|
||
|
|
CViewSetup &CurrentView() { return m_ViewStack.Top().m_View; }
|
||
|
|
|
||
|
|
// Stack of view info
|
||
|
|
struct ViewStack_t
|
||
|
|
{
|
||
|
|
CViewSetup m_View;
|
||
|
|
|
||
|
|
// matrices
|
||
|
|
VMatrix m_matrixView;
|
||
|
|
VMatrix m_matrixProjection;
|
||
|
|
VMatrix m_matrixWorldToScreen;
|
||
|
|
|
||
|
|
bool m_bIs2DView;
|
||
|
|
bool m_bNoDraw;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
// Y field of view, calculated from X FOV and screen aspect ratio.
|
||
|
|
float m_yFOV;
|
||
|
|
|
||
|
|
// timing
|
||
|
|
double m_frameStartTime;
|
||
|
|
float m_framerate;
|
||
|
|
|
||
|
|
float m_zNear;
|
||
|
|
float m_zFar;
|
||
|
|
|
||
|
|
// matrices
|
||
|
|
VMatrix m_matrixView;
|
||
|
|
VMatrix m_matrixProjection;
|
||
|
|
VMatrix m_matrixWorldToScreen;
|
||
|
|
|
||
|
|
CUtlStack< ViewStack_t > m_ViewStack;
|
||
|
|
int m_iLightmapUpdateDepth;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Singleton
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
static CRender gRender;
|
||
|
|
IRender *g_EngineRenderer = &gRender;
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Called when the engine is about to begin rendering for any reason
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CRender::CRender()
|
||
|
|
{
|
||
|
|
// Make sure the stack isn't empty
|
||
|
|
int i = m_ViewStack.Push();
|
||
|
|
memset( &m_ViewStack[i], 0, sizeof( CViewSetup ) );
|
||
|
|
m_ViewStack[i].m_bIs2DView = true;
|
||
|
|
m_iLightmapUpdateDepth = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Called when the engine is about to begin rendering for any reason
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::FrameBegin( void )
|
||
|
|
{
|
||
|
|
if ( host_state.worldmodel )
|
||
|
|
{
|
||
|
|
// This has to be before R_AnimateLight because it uses it to
|
||
|
|
// set the frame number of changed lightstyles
|
||
|
|
|
||
|
|
// FIXME: Why isn't this being done in DrawSceneBegin
|
||
|
|
// or some other client-side simulation of state?
|
||
|
|
r_framecount++;
|
||
|
|
if ( g_RendererInLevel )
|
||
|
|
{
|
||
|
|
R_AnimateLight ();
|
||
|
|
R_PushDlights();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!r_norefresh.GetInt())
|
||
|
|
{
|
||
|
|
m_frameStartTime = Sys_FloatTime ();
|
||
|
|
}
|
||
|
|
|
||
|
|
g_LightmapTransformList.RemoveAll();
|
||
|
|
int index = g_LightmapTransformList.AddToTail();
|
||
|
|
g_LightmapTransformList[index].pModel = host_state.worldmodel;
|
||
|
|
SetIdentityMatrix( g_LightmapTransformList[index].xform );
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateStudioRenderConfig();
|
||
|
|
g_pStudioRender->BeginFrame();
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifndef _CERT
|
||
|
|
|
||
|
|
static void PrintRenderedFaceInfoCallback( int nTopN, IStudioRender::FacesRenderedInfo_t *pFaces, int nTotalFaces )
|
||
|
|
{
|
||
|
|
if ( nTopN > 0 )
|
||
|
|
{
|
||
|
|
con_nprint_s printdesc;
|
||
|
|
printdesc.time_to_live = -1;
|
||
|
|
printdesc.color[0] = printdesc.color[1] = printdesc.color[2] = 1.0f;
|
||
|
|
printdesc.fixed_width_font = false;
|
||
|
|
|
||
|
|
printdesc.index = 1;
|
||
|
|
Con_NXPrintf( &printdesc, "%d total faces in scene", nTotalFaces );
|
||
|
|
++ printdesc.index;
|
||
|
|
Con_NXPrintf( &printdesc, "Printing %d top offending models", nTopN );
|
||
|
|
++ printdesc.index;
|
||
|
|
Con_NXPrintf( &printdesc, "%50s%15s%15s%15s", "Model Name", "# Renders", "Total Tris", "Avg Tris" );
|
||
|
|
for ( int i = 0; i < nTopN; ++ i )
|
||
|
|
{
|
||
|
|
++ printdesc.index;
|
||
|
|
Con_NXPrintf( &printdesc, "%50s%15d%15d%15d", pFaces[i].pStudioHdr->name, pFaces[i].nRenderCount, pFaces[i].nFaceCount, ( int )( ( float )pFaces[i].nFaceCount / ( float )pFaces[i].nRenderCount ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // !_CERT
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Called when the engine has finished rendering
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::FrameEnd( void )
|
||
|
|
{
|
||
|
|
// A debugging overlay that renders all raycasts.
|
||
|
|
// Why, or why is this being done here instead of
|
||
|
|
// where all the other debug overlays are being done in the client DLL?
|
||
|
|
EngineTraceRenderRayCasts();
|
||
|
|
|
||
|
|
m_framerate = GetBaseLocalClient().GetFrameTime();
|
||
|
|
if ( m_framerate > 0 )
|
||
|
|
{
|
||
|
|
m_framerate = 1 / m_framerate;
|
||
|
|
}
|
||
|
|
|
||
|
|
g_pStudioRender->EndFrame();
|
||
|
|
|
||
|
|
#ifndef _CERT
|
||
|
|
g_pStudioRender->GatherRenderedFaceInfo( PrintRenderedFaceInfoCallback );
|
||
|
|
#endif // !_CERT
|
||
|
|
|
||
|
|
g_LightmapTransformList.RemoveAll();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
const VMatrix &CRender::ViewMatrix( )
|
||
|
|
{
|
||
|
|
// If we aren't in a valid view, then use the last value cached off into the global variable instead
|
||
|
|
if ( m_ViewStack.Count() > 1 )
|
||
|
|
{
|
||
|
|
return m_ViewStack.Top().m_matrixView;
|
||
|
|
}
|
||
|
|
return m_matrixView;
|
||
|
|
}
|
||
|
|
|
||
|
|
const VMatrix &CRender::WorldToScreenMatrix( void )
|
||
|
|
{
|
||
|
|
// If we aren't in a valid view, then use the last value cached off into the global variable instead
|
||
|
|
if ( m_ViewStack.Count() > 1 )
|
||
|
|
{
|
||
|
|
return m_ViewStack.Top().m_matrixWorldToScreen;
|
||
|
|
}
|
||
|
|
return m_matrixWorldToScreen;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::ViewSetupVis( bool novis, int numorigins, const Vector origin[] )
|
||
|
|
{
|
||
|
|
unsigned int returnFlags = 0;
|
||
|
|
ViewSetupVisEx( novis, numorigins, origin, returnFlags );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::ViewSetupVisEx( bool novis, int numorigins, const Vector origin[], unsigned int &returnFlags )
|
||
|
|
{
|
||
|
|
Map_VisSetup( host_state.worldmodel, numorigins, origin, novis, returnFlags );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Called when a particular view becomes active
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::OnViewActive( Frustum frustumPlanes )
|
||
|
|
{
|
||
|
|
const CViewSetup &view = CurrentView();
|
||
|
|
|
||
|
|
m_yFOV = CalcFovY( view.fov, view.m_flAspectRatio );
|
||
|
|
|
||
|
|
// build the transformation matrix for the given view angles
|
||
|
|
VectorCopy( view.origin, g_CurrentViewOrigin );
|
||
|
|
AngleVectors( view.angles, &g_CurrentViewForward, &g_CurrentViewRight, &g_CurrentViewUp );
|
||
|
|
// g_CurrentViewUp = -g_CurrentViewUp;
|
||
|
|
g_bCanAccessCurrentView = true;
|
||
|
|
|
||
|
|
if ( frustumPlanes )
|
||
|
|
{
|
||
|
|
if ( view.m_bOrtho )
|
||
|
|
{
|
||
|
|
OrthoExtractFrustumPlanes( frustumPlanes );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ExtractFrustumPlanes( frustumPlanes );
|
||
|
|
}
|
||
|
|
|
||
|
|
OcclusionSystem()->SetView( view.origin, view.fov, m_matrixView, m_matrixProjection, frustumPlanes[ FRUSTUM_NEARZ ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !m_ViewStack.Top().m_bNoDraw )
|
||
|
|
{
|
||
|
|
R_SceneBegin( );
|
||
|
|
}
|
||
|
|
|
||
|
|
// debug, build leaf volume
|
||
|
|
// NOTE: This is pretty hacky, but I want the leaf based on the main view. The skybox view is reseting
|
||
|
|
// the g_LeafVis here because it is global. This need to be resolved more correctly some other way!
|
||
|
|
if ( VectorCompare( MainViewOrigin(), view.origin ) )
|
||
|
|
{
|
||
|
|
LeafVisBuild( view.origin );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Clear the view (assumes the render target has already been pushed)
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::ClearView( IMatRenderContext *pRenderContext, CViewSetup &view, int nFlags, ITexture* pRenderTarget, ITexture* pDepthTexture /* = NULL */ )
|
||
|
|
{
|
||
|
|
bool bClearColor = (nFlags & VIEW_CLEAR_COLOR) != 0;
|
||
|
|
bool bClearDepth = (nFlags & VIEW_CLEAR_DEPTH) != 0;
|
||
|
|
bool bClearStencil = (nFlags & VIEW_CLEAR_STENCIL) != 0;
|
||
|
|
bool bForceClearWholeRenderTarget = (nFlags & VIEW_CLEAR_FULL_TARGET) != 0;
|
||
|
|
bool bObeyStencil = (nFlags & VIEW_CLEAR_OBEY_STENCIL) != 0;
|
||
|
|
|
||
|
|
// Handle an initial clear request if asked for
|
||
|
|
if ( !bClearColor && !bClearDepth && !bClearStencil )
|
||
|
|
return;
|
||
|
|
|
||
|
|
if ( !bForceClearWholeRenderTarget )
|
||
|
|
{
|
||
|
|
if( bObeyStencil )
|
||
|
|
{
|
||
|
|
pRenderContext->ClearBuffersObeyStencil( bClearColor, bClearDepth );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pRenderContext->ClearBuffers( bClearColor, bClearDepth, bClearStencil );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Get the render target dimensions
|
||
|
|
int nWidth, nHeight;
|
||
|
|
if ( pRenderTarget )
|
||
|
|
{
|
||
|
|
nWidth = pRenderTarget->GetActualWidth();
|
||
|
|
nHeight = pRenderTarget->GetActualHeight();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
materials->GetBackBufferDimensions( nWidth, nHeight );
|
||
|
|
}
|
||
|
|
|
||
|
|
pRenderContext->PushRenderTargetAndViewport( pRenderTarget, pDepthTexture, 0, 0, nWidth, nHeight );
|
||
|
|
|
||
|
|
if( bObeyStencil )
|
||
|
|
{
|
||
|
|
pRenderContext->ClearBuffersObeyStencil( bClearColor, bClearDepth );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pRenderContext->ClearBuffers( bClearColor, bClearDepth, bClearStencil );
|
||
|
|
}
|
||
|
|
|
||
|
|
pRenderContext->PopRenderTargetAndViewport( );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Push, pop views
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::Push3DView( IMatRenderContext *pRenderContext, const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes )
|
||
|
|
{
|
||
|
|
Push3DView( pRenderContext, view, nFlags, pRenderTarget, frustumPlanes, NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Flip y, screen y goes down
|
||
|
|
static VMatrix g_ProjectionToOffset( 0.5f, 0.0f, 0.0f, 0.5f,
|
||
|
|
0.0f, -0.5f, 0.0f, 0.5f,
|
||
|
|
0.0f, 0.0f, 1.0f, 0.0f,
|
||
|
|
0.0f, 0.0f, 0.0f, 1.0f );
|
||
|
|
|
||
|
|
// NOTE: Screen coordinates go from 0->w, 0->h
|
||
|
|
void ComputeWorldToScreenMatrix( VMatrix *pWorldToScreen, const VMatrix &worldToProjection, const CViewSetup &viewSetup )
|
||
|
|
{
|
||
|
|
// First need to transform -1 -> 1 to 0 -> 1 in x and y
|
||
|
|
// Then transform from 0->1 to x->w+x in x, and 0->1 to y->y+h in y.
|
||
|
|
VMatrix offsetToPixels( viewSetup.width, 0.0f, 0.0f, viewSetup.x,
|
||
|
|
0.0f, viewSetup.height, 0.0f, viewSetup.y,
|
||
|
|
0.0f, 0.0f, 1.0f, 0.0f,
|
||
|
|
0.0f, 0.0f, 0.0f, 1.0f );
|
||
|
|
|
||
|
|
VMatrix projectionToPixels;
|
||
|
|
MatrixMultiply( offsetToPixels, g_ProjectionToOffset, projectionToPixels );
|
||
|
|
MatrixMultiply( projectionToPixels, worldToProjection, *pWorldToScreen );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Push, pop views
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::Push3DView( IMatRenderContext *pRenderContext, const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes, ITexture* pDepthTexture )
|
||
|
|
{
|
||
|
|
Assert( !IsX360() || (pDepthTexture == NULL) ); //Don't render to a depth texture on the 360. Instead, render using a normal depth buffer and use IDirect3DDevice9::Resolve()
|
||
|
|
|
||
|
|
int i = m_ViewStack.Push( );
|
||
|
|
m_ViewStack[i].m_View = view;
|
||
|
|
m_ViewStack[i].m_bIs2DView = false;
|
||
|
|
m_ViewStack[i].m_bNoDraw = ( ( nFlags & VIEW_NO_DRAW ) != 0 );
|
||
|
|
|
||
|
|
CViewSetup &topView = m_ViewStack[i].m_View;
|
||
|
|
|
||
|
|
// Compute aspect ratio if asked for
|
||
|
|
if ( topView.m_flAspectRatio == 0.0f )
|
||
|
|
{
|
||
|
|
topView.m_flAspectRatio = (topView.height != 0) ? ( (float)topView.width / (float)topView.height ) : 1.0f;
|
||
|
|
}
|
||
|
|
|
||
|
|
ViewStack_t &viewStack = m_ViewStack.Top();
|
||
|
|
topView.m_flAspectRatio = topView.ComputeViewMatrices( &viewStack.m_matrixView,
|
||
|
|
&viewStack.m_matrixProjection, &viewStack.m_matrixWorldToScreen );
|
||
|
|
|
||
|
|
m_zNear = topView.zNear;
|
||
|
|
m_zFar = topView.zFar; // cache this for queries
|
||
|
|
|
||
|
|
ExtractMatrices();
|
||
|
|
|
||
|
|
if ( !m_ViewStack[i].m_bNoDraw )
|
||
|
|
{
|
||
|
|
if ( !pRenderTarget )
|
||
|
|
{
|
||
|
|
pRenderTarget = pRenderContext->GetRenderTarget();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Push render target and viewport
|
||
|
|
pRenderContext->PushRenderTargetAndViewport( pRenderTarget, pDepthTexture, topView.x, topView.y, topView.width, topView.height );
|
||
|
|
|
||
|
|
// Handle an initial clear request if asked for
|
||
|
|
ClearView( pRenderContext, topView, nFlags, pRenderTarget, pDepthTexture );
|
||
|
|
|
||
|
|
pRenderContext->DepthRange( 0, 1 );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadMatrix( m_matrixProjection );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadMatrix( m_matrixView );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
|
||
|
|
OnViewActive( frustumPlanes );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::Push2DView( IMatRenderContext *pRenderContext, const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes )
|
||
|
|
{
|
||
|
|
int i = m_ViewStack.Push( );
|
||
|
|
m_ViewStack[i].m_View = view;
|
||
|
|
m_ViewStack[i].m_bIs2DView = true;
|
||
|
|
m_ViewStack[i].m_bNoDraw = ( ( nFlags & VIEW_NO_DRAW ) != 0 );
|
||
|
|
m_ViewStack[i].m_matrixView = m_matrixView;
|
||
|
|
m_ViewStack[i].m_matrixProjection = m_matrixProjection;
|
||
|
|
m_ViewStack[i].m_matrixWorldToScreen = m_matrixWorldToScreen;
|
||
|
|
|
||
|
|
CViewSetup &topView = m_ViewStack[i].m_View;
|
||
|
|
g_bCanAccessCurrentView = false;
|
||
|
|
|
||
|
|
if ( !pRenderTarget )
|
||
|
|
{
|
||
|
|
pRenderTarget = pRenderContext->GetRenderTarget();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Push render target and viewport
|
||
|
|
pRenderContext->PushRenderTargetAndViewport( pRenderTarget, topView.x, topView.y, topView.width, topView.height );
|
||
|
|
|
||
|
|
// Handle an initial clear request if asked for
|
||
|
|
ClearView( pRenderContext, topView, nFlags, pRenderTarget );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
pRenderContext->Scale( 1, -1, 1 );
|
||
|
|
pRenderContext->Ortho( 0, 0, topView.width, topView.height, -99999, 99999 );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::PopView( IMatRenderContext *pRenderContext, Frustum frustumPlanes )
|
||
|
|
{
|
||
|
|
if ( !m_ViewStack.Top().m_bNoDraw )
|
||
|
|
{
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
|
||
|
|
pRenderContext->PopRenderTargetAndViewport( );
|
||
|
|
}
|
||
|
|
|
||
|
|
bool bReset = ( m_ViewStack.Count() > 1 ) ? true : false;
|
||
|
|
m_ViewStack.Pop();
|
||
|
|
|
||
|
|
// Don't pop off the very last view
|
||
|
|
g_bCanAccessCurrentView = false;
|
||
|
|
|
||
|
|
if ( bReset )
|
||
|
|
{
|
||
|
|
if ( !m_ViewStack.Top().m_bIs2DView )
|
||
|
|
{
|
||
|
|
ExtractMatrices();
|
||
|
|
|
||
|
|
m_zNear = m_ViewStack.Top().m_View.zNear;
|
||
|
|
m_zFar = m_ViewStack.Top().m_View.zFar;
|
||
|
|
|
||
|
|
OnViewActive( frustumPlanes );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Sets the main 3D view (for console commands, sound, etc.)
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CRender::SetMainView( const Vector &vecOrigin, const QAngle &angles )
|
||
|
|
{
|
||
|
|
ASSERT_LOCAL_PLAYER_RESOLVABLE();
|
||
|
|
int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT();
|
||
|
|
|
||
|
|
VectorCopy( vecOrigin, g_MainViewOrigin[ nSlot ] );
|
||
|
|
AngleVectors( angles, &g_MainViewForward[ nSlot ], &g_MainViewRight[ nSlot ], &g_MainViewUp[ nSlot ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::BeginUpdateLightmaps( void )
|
||
|
|
{
|
||
|
|
if ( ++m_iLightmapUpdateDepth == 1)
|
||
|
|
{
|
||
|
|
Assert( g_LightmapUpdateList.Count() == 0 );
|
||
|
|
materials->BeginUpdateLightmaps();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::UpdateBrushModelLightmap( model_t *model, IClientRenderable *pRenderable )
|
||
|
|
{
|
||
|
|
AssertOnce( m_iLightmapUpdateDepth );
|
||
|
|
|
||
|
|
if( !r_drawbrushmodels.GetBool() || !m_iLightmapUpdateDepth )
|
||
|
|
return;
|
||
|
|
|
||
|
|
R_MarkDlightsOnBrushModel( model, pRenderable );
|
||
|
|
bool bLightingChanged = Mod_NeedsLightstyleUpdate( model );
|
||
|
|
|
||
|
|
if ( (model->flags & MODELFLAG_HAS_DLIGHT) || bLightingChanged )
|
||
|
|
{
|
||
|
|
int transformIndex = g_LightmapTransformList.AddToTail();
|
||
|
|
LightmapTransformInfo_t &transform = g_LightmapTransformList[transformIndex];
|
||
|
|
transform.pModel = model;
|
||
|
|
AngleMatrix( pRenderable->GetRenderAngles(), pRenderable->GetRenderOrigin(), transform.xform );
|
||
|
|
SurfaceHandle_t surfID = SurfaceHandleFromIndex( model->brush.firstmodelsurface, model->brush.pShared );
|
||
|
|
bool bLight = false;
|
||
|
|
for (int i=0 ; i<model->brush.nummodelsurfaces ; i++, surfID++)
|
||
|
|
{
|
||
|
|
if ( MSurf_Flags(surfID) & (SURFDRAW_HASDLIGHT|SURFDRAW_HASLIGHTSYTLES) )
|
||
|
|
{
|
||
|
|
R_CheckForLightmapUpdates( surfID, transformIndex );
|
||
|
|
if ( MSurf_Flags(surfID) & SURFDRAW_HASDLIGHT )
|
||
|
|
{
|
||
|
|
bLight = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( !bLight )
|
||
|
|
{
|
||
|
|
model->flags &= ~MODELFLAG_HAS_DLIGHT; // don't need to check again unless a dlight hits us
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( bLightingChanged )
|
||
|
|
{
|
||
|
|
model->brush.nLightstyleLastComputedFrame = r_framecount;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::EndUpdateLightmaps( void )
|
||
|
|
{
|
||
|
|
Assert( m_iLightmapUpdateDepth > 0 );
|
||
|
|
if ( --m_iLightmapUpdateDepth == 0 )
|
||
|
|
{
|
||
|
|
VPROF_BUDGET( "EndUpdateLightmaps", VPROF_BUDGETGROUP_DLIGHT_RENDERING );
|
||
|
|
if ( g_LightmapUpdateList.Count() && r_dynamiclighting.GetBool() && !r_unloadlightmaps.GetBool() )
|
||
|
|
{
|
||
|
|
VPROF_("R_BuildLightmapUpdateList", 1, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0);
|
||
|
|
R_BuildLightmapUpdateList();
|
||
|
|
}
|
||
|
|
{
|
||
|
|
VPROF_("materials_EndUpdateLightmaps", 1, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0);
|
||
|
|
materials->EndUpdateLightmaps();
|
||
|
|
}
|
||
|
|
{
|
||
|
|
g_LightmapUpdateList.RemoveAll();
|
||
|
|
VPROF_("lightmap_RemoveAll", 1, VPROF_BUDGETGROUP_DLIGHT_RENDERING, false, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CRender::InLightmapUpdate( void ) const
|
||
|
|
{
|
||
|
|
return ( m_iLightmapUpdateDepth != 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Compute the scene coordinates of a point in 3D
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CRender::ClipTransform( const Vector& point, Vector* pClip )
|
||
|
|
{
|
||
|
|
// UNDONE: Clean this up some, handle off-screen vertices
|
||
|
|
float w;
|
||
|
|
const VMatrix &worldToScreen = g_EngineRenderer->WorldToScreenMatrix();
|
||
|
|
|
||
|
|
pClip->x = worldToScreen[0][0] * point[0] + worldToScreen[0][1] * point[1] + worldToScreen[0][2] * point[2] + worldToScreen[0][3];
|
||
|
|
pClip->y = worldToScreen[1][0] * point[0] + worldToScreen[1][1] * point[1] + worldToScreen[1][2] * point[2] + worldToScreen[1][3];
|
||
|
|
// z = worldToScreen[2][0] * point[0] + worldToScreen[2][1] * point[1] + worldToScreen[2][2] * point[2] + worldToScreen[2][3];
|
||
|
|
w = worldToScreen[3][0] * point[0] + worldToScreen[3][1] * point[1] + worldToScreen[3][2] * point[2] + worldToScreen[3][3];
|
||
|
|
|
||
|
|
// Just so we have something valid here
|
||
|
|
pClip->z = 0.0f;
|
||
|
|
|
||
|
|
bool behind;
|
||
|
|
if( w < 0.001f )
|
||
|
|
{
|
||
|
|
behind = true;
|
||
|
|
pClip->x *= 100000;
|
||
|
|
pClip->y *= 100000;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
behind = false;
|
||
|
|
float invw = 1.0f / w;
|
||
|
|
pClip->x *= invw;
|
||
|
|
pClip->y *= invw;
|
||
|
|
}
|
||
|
|
|
||
|
|
return behind;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Given a point, return the screen position in pixels
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
bool CRender::ScreenTransform( const Vector& point, Vector* pScreen )
|
||
|
|
{
|
||
|
|
bool retval = ClipTransform( point, pScreen );
|
||
|
|
|
||
|
|
pScreen->x = 0.5f * ( pScreen->x + 1.0f ) * CurrentView().width + CurrentView().x;
|
||
|
|
pScreen->y = 0.5f * ( pScreen->y + 1.0f ) * CurrentView().height + CurrentView().y;
|
||
|
|
|
||
|
|
return retval;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::ViewDrawFade( byte *color, IMaterial* pFadeMaterial, bool mapFullTextureToScreen )
|
||
|
|
{
|
||
|
|
if ( !color || !color[3] )
|
||
|
|
return;
|
||
|
|
|
||
|
|
if( !pFadeMaterial )
|
||
|
|
return;
|
||
|
|
|
||
|
|
const CViewSetup &view = CurrentView();
|
||
|
|
|
||
|
|
CMatRenderContextPtr pRenderContext( materials );
|
||
|
|
|
||
|
|
pRenderContext->PushRenderTargetAndViewport();
|
||
|
|
|
||
|
|
pRenderContext->Bind( pFadeMaterial );
|
||
|
|
pFadeMaterial->AlphaModulate( color[3] * ( 1.0f / 255.0f ) );
|
||
|
|
pFadeMaterial->ColorModulate( color[0] * ( 1.0f / 255.0f ),
|
||
|
|
color[1] * ( 1.0f / 255.0f ),
|
||
|
|
color[2] * ( 1.0f / 255.0f ) );
|
||
|
|
|
||
|
|
bool bOldIgnoreZ = pFadeMaterial->GetMaterialVarFlag( MATERIAL_VAR_IGNOREZ );
|
||
|
|
pFadeMaterial->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
|
||
|
|
|
||
|
|
int nTexWidth, nTexHeight;
|
||
|
|
nTexWidth = pFadeMaterial->GetMappingWidth();
|
||
|
|
nTexHeight = pFadeMaterial->GetMappingHeight();
|
||
|
|
float flUOffset = 0.5f / nTexWidth;
|
||
|
|
float flVOffset = 0.5f / nTexHeight;
|
||
|
|
|
||
|
|
int width, height;
|
||
|
|
pRenderContext->GetRenderTargetDimensions( width, height );
|
||
|
|
pRenderContext->Viewport( 0, 0, width, height );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
|
||
|
|
pRenderContext->Scale( 1, -1, 1 );
|
||
|
|
pRenderContext->Ortho( 0, 0, width, height, -99999, 99999 );
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PushMatrix();
|
||
|
|
pRenderContext->LoadIdentity();
|
||
|
|
|
||
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh();
|
||
|
|
CMeshBuilder meshBuilder;
|
||
|
|
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
|
||
|
|
|
||
|
|
// adjusted xys
|
||
|
|
float x1=view.x-.5;
|
||
|
|
float x2=view.x+view.width;
|
||
|
|
float y1=view.y-.5;
|
||
|
|
float y2=view.y+view.height;
|
||
|
|
|
||
|
|
float u1, u2, v1, v2;
|
||
|
|
|
||
|
|
if ( mapFullTextureToScreen )
|
||
|
|
{
|
||
|
|
// adjust nominal uvs to reflect adjusted xys
|
||
|
|
u1=FLerp(flUOffset, 1-flUOffset,view.x,view.x+view.width,x1);
|
||
|
|
u2=FLerp(flUOffset, 1-flUOffset,view.x,view.x+view.width,x2);
|
||
|
|
v1=FLerp(flVOffset, 1-flVOffset,view.y,view.y+view.height,y1);
|
||
|
|
v2=FLerp(flVOffset, 1-flVOffset,view.y,view.y+view.height,y2);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Match up the view port window with a corresponding window in the fade texture.
|
||
|
|
// This is mainly for split screen support.
|
||
|
|
u1 = Lerp( x1 / (float)width, flUOffset, 1-flUOffset );
|
||
|
|
u2 = Lerp( x2 / (float)width, flUOffset, 1-flUOffset );
|
||
|
|
v1 = Lerp( y1 / (float)height, flVOffset, 1-flVOffset );
|
||
|
|
v2 = Lerp( y2 / (float)height, flVOffset, 1-flVOffset );
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int corner=0; corner<4; corner++ )
|
||
|
|
{
|
||
|
|
bool left=(corner==0) || (corner==3);
|
||
|
|
meshBuilder.Position3f( (left) ? x1 : x2, (corner & 2) ? y2 : y1, 0.0f );
|
||
|
|
meshBuilder.TexCoord2f( 0, (left) ? u1 : u2, (corner & 2) ? v2 : v1 );
|
||
|
|
meshBuilder.AdvanceVertex();
|
||
|
|
}
|
||
|
|
meshBuilder.End();
|
||
|
|
pMesh->Draw();
|
||
|
|
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
||
|
|
pRenderContext->PopMatrix();
|
||
|
|
|
||
|
|
pFadeMaterial->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, bOldIgnoreZ );
|
||
|
|
|
||
|
|
pRenderContext->PopRenderTargetAndViewport();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::ExtractFrustumPlanes( Frustum frustumPlanes )
|
||
|
|
{
|
||
|
|
const CViewSetup &view = CurrentView();
|
||
|
|
|
||
|
|
GeneratePerspectiveFrustum( CurrentViewOrigin(),
|
||
|
|
CurrentViewForward(), CurrentViewRight(), CurrentViewUp(),
|
||
|
|
view.zNear, view.zFar, view.fov, m_yFOV, frustumPlanes );
|
||
|
|
g_Frustum.SetPlanes(frustumPlanes);
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::OrthoExtractFrustumPlanes( Frustum frustumPlanes )
|
||
|
|
{
|
||
|
|
const CViewSetup &view = CurrentView();
|
||
|
|
|
||
|
|
// Setup the near and far planes.
|
||
|
|
float orgOffset = DotProduct(CurrentViewOrigin(), CurrentViewForward());
|
||
|
|
frustumPlanes[FRUSTUM_FARZ].m_Normal = -CurrentViewForward();
|
||
|
|
frustumPlanes[FRUSTUM_FARZ].m_Dist = -view.zFar - orgOffset;
|
||
|
|
|
||
|
|
frustumPlanes[FRUSTUM_NEARZ].m_Normal = CurrentViewForward();
|
||
|
|
frustumPlanes[FRUSTUM_NEARZ].m_Dist = view.zNear + orgOffset;
|
||
|
|
|
||
|
|
// Left and right planes...
|
||
|
|
orgOffset = DotProduct(CurrentViewOrigin(), CurrentViewRight());
|
||
|
|
frustumPlanes[FRUSTUM_LEFT].m_Normal = CurrentViewRight();
|
||
|
|
frustumPlanes[FRUSTUM_LEFT].m_Dist = view.m_OrthoLeft + orgOffset;
|
||
|
|
|
||
|
|
frustumPlanes[FRUSTUM_RIGHT].m_Normal = -CurrentViewRight();
|
||
|
|
frustumPlanes[FRUSTUM_RIGHT].m_Dist = -view.m_OrthoRight - orgOffset;
|
||
|
|
|
||
|
|
// Top and buttom planes...
|
||
|
|
orgOffset = DotProduct(CurrentViewOrigin(), CurrentViewUp());
|
||
|
|
frustumPlanes[FRUSTUM_TOP].m_Normal = CurrentViewUp();
|
||
|
|
frustumPlanes[FRUSTUM_TOP].m_Dist = view.m_OrthoTop + orgOffset;
|
||
|
|
|
||
|
|
frustumPlanes[FRUSTUM_BOTTOM].m_Normal = -CurrentViewUp();
|
||
|
|
frustumPlanes[FRUSTUM_BOTTOM].m_Dist = -view.m_OrthoBottom - orgOffset;
|
||
|
|
|
||
|
|
g_Frustum.SetPlanes( frustumPlanes );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::OverrideViewFrustum( Frustum custom )
|
||
|
|
{
|
||
|
|
g_Frustum.SetPlanes( custom );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::ExtractMatrices( void )
|
||
|
|
{
|
||
|
|
m_matrixView = m_ViewStack.Top().m_matrixView;
|
||
|
|
m_matrixProjection = m_ViewStack.Top().m_matrixProjection;
|
||
|
|
m_matrixWorldToScreen = m_ViewStack.Top().m_matrixWorldToScreen;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::SetViewport( int x, int y, int w, int h )
|
||
|
|
{
|
||
|
|
int x2, y2;
|
||
|
|
int windowWidth = w, windowHeight = h;
|
||
|
|
|
||
|
|
CMatRenderContextPtr pRenderContext( materials );
|
||
|
|
|
||
|
|
// set the viewport to be out to the size of the render target, unless explicitly told not to
|
||
|
|
if (!CurrentView().m_bRenderToSubrectOfLargerScreen)
|
||
|
|
{
|
||
|
|
pRenderContext->GetRenderTargetDimensions( windowWidth, windowHeight );
|
||
|
|
}
|
||
|
|
|
||
|
|
x2 = (x + w);
|
||
|
|
y2 = (windowHeight - (y + h));
|
||
|
|
y = (windowHeight - y);
|
||
|
|
|
||
|
|
// fudge around because of frac screen scale
|
||
|
|
if (x > 0)
|
||
|
|
x--;
|
||
|
|
if (x2 < windowWidth)
|
||
|
|
x2++;
|
||
|
|
if (y2 < 0)
|
||
|
|
y2--;
|
||
|
|
if (y < windowHeight)
|
||
|
|
y++;
|
||
|
|
|
||
|
|
w = x2 - x;
|
||
|
|
h = y - y2;
|
||
|
|
|
||
|
|
pRenderContext->Viewport( x, y2, w, h );
|
||
|
|
}
|
||
|
|
|
||
|
|
void DrawLightmapPage( int lightmapPageID )
|
||
|
|
{
|
||
|
|
// assumes that we are already in ortho mode.
|
||
|
|
int lightmapPageWidth, lightmapPageHeight;
|
||
|
|
|
||
|
|
CMatRenderContextPtr pRenderContext( materials );
|
||
|
|
|
||
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, g_materialDebugLightmap );
|
||
|
|
// pRenderContext->Bind( g_materialWireframe );
|
||
|
|
// IMesh* pMesh = pRenderContext->GetDynamicMesh( g_materialWireframe );
|
||
|
|
|
||
|
|
materials->GetLightmapPageSize( lightmapPageID, &lightmapPageWidth, &lightmapPageHeight );
|
||
|
|
pRenderContext->BindLightmapPage( lightmapPageID );
|
||
|
|
|
||
|
|
CMeshBuilder meshBuilder;
|
||
|
|
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
|
||
|
|
|
||
|
|
int x = 0;
|
||
|
|
int y = 0;
|
||
|
|
|
||
|
|
float s = 1.0f;
|
||
|
|
float t = 1.0f;
|
||
|
|
|
||
|
|
// texcoord 1 is lightmaptexcoord for fixed function.
|
||
|
|
meshBuilder.TexCoord2f( 1, 0.0f, 0.0f );
|
||
|
|
meshBuilder.Position3f( x, y, 0.0f );
|
||
|
|
meshBuilder.AdvanceVertex();
|
||
|
|
|
||
|
|
meshBuilder.TexCoord2f( 1, s, 0.0f );
|
||
|
|
meshBuilder.Position3f( x+lightmapPageWidth, y, 0.0f );
|
||
|
|
meshBuilder.AdvanceVertex();
|
||
|
|
|
||
|
|
meshBuilder.TexCoord2f( 1, s, t );
|
||
|
|
meshBuilder.Position3f( x+lightmapPageWidth, y+lightmapPageHeight, 0.0f );
|
||
|
|
meshBuilder.AdvanceVertex();
|
||
|
|
|
||
|
|
meshBuilder.TexCoord2f( 1, 0.0f, t );
|
||
|
|
meshBuilder.Position3f( x, y+lightmapPageHeight, 0.0f );
|
||
|
|
meshBuilder.AdvanceVertex();
|
||
|
|
|
||
|
|
meshBuilder.End();
|
||
|
|
pMesh->Draw();
|
||
|
|
}
|
||
|
|
|
||
|
|
//hack
|
||
|
|
extern void DebugDrawLightmapAtCrossHair();
|
||
|
|
|
||
|
|
void R_DrawLightmaps( IWorldRenderList *pList, int pageId )
|
||
|
|
{
|
||
|
|
#ifdef USE_CONVARS
|
||
|
|
if ( pageId != -1 )
|
||
|
|
{
|
||
|
|
DrawLightmapPage( pageId );
|
||
|
|
Shader_DrawLightmapPageChains( pList, pageId );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void R_CheckForLightingConfigChanges()
|
||
|
|
{
|
||
|
|
if ( !materials->CanDownloadTextures() )
|
||
|
|
return;
|
||
|
|
|
||
|
|
UpdateStudioRenderConfig();
|
||
|
|
UpdateMaterialSystemConfig();
|
||
|
|
if( MaterialConfigLightingChanged() || g_RebuildLightmaps )
|
||
|
|
{
|
||
|
|
ClearMaterialConfigLightingChanged();
|
||
|
|
DevMsg( "Redownloading all lightmaps\n" );
|
||
|
|
BuildGammaTable( 2.2f, 2.2f, 0.0f, OVERBRIGHT );
|
||
|
|
R_RedownloadAllLightmaps();
|
||
|
|
StaticPropMgr()->RecomputeStaticLighting();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ConVar r_redownloadallpaintmaps("r_redownloadallpaintmaps", "0", FCVAR_DEVELOPMENTONLY);
|
||
|
|
void R_CheckForPaintmapChanges()
|
||
|
|
{
|
||
|
|
if ( !g_PaintManager.m_bShouldRegister )
|
||
|
|
return;
|
||
|
|
|
||
|
|
if ( !materials->CanDownloadTextures() )
|
||
|
|
return;
|
||
|
|
|
||
|
|
if ( r_redownloadallpaintmaps.GetBool() )
|
||
|
|
{
|
||
|
|
R_RedownloadAllPaintmaps();
|
||
|
|
r_redownloadallpaintmaps.SetValue(0);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
VPROF_BUDGET( "R_CheckForPaintmapChanges", "paint" );
|
||
|
|
g_PaintManager.UpdatePaintmapTextures();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void CRender::DrawSceneBegin( void )
|
||
|
|
{
|
||
|
|
R_CheckForLightingConfigChanges();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CRender::DrawSceneEnd( void )
|
||
|
|
{
|
||
|
|
R_SceneEnd();
|
||
|
|
LeafVisDraw();
|
||
|
|
}
|
||
|
|
|
||
|
|
IWorldRenderList * CRender::CreateWorldList()
|
||
|
|
{
|
||
|
|
return AllocWorldRenderList();
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(_PS3)
|
||
|
|
IWorldRenderList * CRender::CreateWorldList_PS3( int viewID )
|
||
|
|
{
|
||
|
|
return AllocWorldRenderList_PS3( viewID );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
// JasonM TODO: optimize in the case of shadow depth mapping (i.e. don't update lightmaps)
|
||
|
|
void CRender::BuildWorldLists( IWorldRenderList *pList, WorldListInfo_t* pInfo, int iForceViewLeaf, const VisOverrideData_t* pVisData, bool bShadowDepth, float *pWaterReflectionHeight )
|
||
|
|
{
|
||
|
|
VPROF_INCREMENT_COUNTER( "BuildWorldLists", 1 );
|
||
|
|
|
||
|
|
Assert( pList );
|
||
|
|
Assert( m_iLightmapUpdateDepth > 0 || g_LightmapUpdateList.Count() == 0 );
|
||
|
|
|
||
|
|
if ( !bShadowDepth )
|
||
|
|
{
|
||
|
|
BeginUpdateLightmaps();
|
||
|
|
}
|
||
|
|
|
||
|
|
R_BuildWorldLists( pList, pInfo, iForceViewLeaf, pVisData, bShadowDepth, pWaterReflectionHeight );
|
||
|
|
|
||
|
|
if ( !bShadowDepth )
|
||
|
|
{
|
||
|
|
EndUpdateLightmaps();
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( m_iLightmapUpdateDepth > 0 || g_LightmapUpdateList.Count() == 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(_PS3)
|
||
|
|
void CRender::BuildWorldLists_PS3_Epilogue( IWorldRenderList *pList, WorldListInfo_t* pInfo, bool bShadowDepth )
|
||
|
|
{
|
||
|
|
Assert( pList );
|
||
|
|
|
||
|
|
R_BuildWorldLists_PS3_Epilogue( pList, pInfo, bShadowDepth );
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
void CRender::BuildWorldLists_Epilogue( IWorldRenderList *pList, WorldListInfo_t* pInfo, bool bShadowDepth )
|
||
|
|
{
|
||
|
|
Assert( pList );
|
||
|
|
Assert( m_iLightmapUpdateDepth > 0 || g_LightmapUpdateList.Count() == 0 );
|
||
|
|
|
||
|
|
if ( !bShadowDepth )
|
||
|
|
{
|
||
|
|
BeginUpdateLightmaps();
|
||
|
|
}
|
||
|
|
|
||
|
|
R_BuildWorldLists_Epilogue( pList, pInfo, bShadowDepth );
|
||
|
|
|
||
|
|
if ( !bShadowDepth )
|
||
|
|
{
|
||
|
|
EndUpdateLightmaps();
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert( m_iLightmapUpdateDepth > 0 || g_LightmapUpdateList.Count() == 0 );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
void CRender::DrawWorldLists( IMatRenderContext *pRenderContext, IWorldRenderList *pList, unsigned long flags, float flWaterZAdjust )
|
||
|
|
{
|
||
|
|
Assert( ( flags & DRAWWORLDLISTS_DRAW_SIMPLE_WORLD_MODEL ) || pList );
|
||
|
|
R_DrawWorldLists( pRenderContext, pList, flags, flWaterZAdjust );
|
||
|
|
}
|
||
|
|
|