1255 lines
38 KiB
C++
1255 lines
38 KiB
C++
//========= Copyright 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"
|
|
|
|
// 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"
|
|
#if !defined( _X360 )
|
|
, FCVAR_CHEAT
|
|
#endif
|
|
);
|
|
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, g_MainViewForward, g_MainViewRight, g_MainViewUp;
|
|
bool g_bCanAccessCurrentView = false;
|
|
|
|
int d_lightstyleframe[256];
|
|
|
|
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 aspect ratio of the screen
|
|
//-----------------------------------------------------------------------------
|
|
float GetScreenAspect( )
|
|
{
|
|
// use the override if set
|
|
if ( r_aspectratio.GetFloat() > 0.0f )
|
|
return r_aspectratio.GetFloat();
|
|
|
|
// mikesart: This is just sticking in unnecessary BeginRender/EndRender calls to the queue.
|
|
// CMatRenderContextPtr pRenderContext( materials );
|
|
IMatRenderContext *pRenderContext = g_pMaterialSystem->GetRenderContext();
|
|
|
|
int width, height;
|
|
pRenderContext->GetRenderTargetDimensions( width, height );
|
|
return (height != 0) ? ( (float)width / (float)height ) : 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.Size(); 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 );
|
|
|
|
IWorldRenderList * CreateWorldList();
|
|
void BuildWorldLists( IWorldRenderList *pList, WorldListInfo_t* pInfo, int iForceViewLeaf, const VisOverrideData_t* pVisData, bool bShadowDepth, float *pWaterReflectionHeight );
|
|
void DrawWorldLists( 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 ClipTransformWithProjection ( const VMatrix& worldToScreen, const Vector& point, Vector* pClip );
|
|
virtual bool ClipTransform( const Vector& point, Vector* pClip );
|
|
virtual bool ScreenTransform( const Vector& point, Vector* pScreen );
|
|
|
|
virtual void Push3DView( const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes );
|
|
virtual void Push3DView( const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes, ITexture* pDepthTexture );
|
|
virtual void Push2DView( const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes );
|
|
virtual void PopView( 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( 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++;
|
|
R_AnimateLight ();
|
|
R_PushDlights();
|
|
|
|
if (!r_norefresh.GetInt())
|
|
{
|
|
m_frameStartTime = Sys_FloatTime ();
|
|
}
|
|
}
|
|
|
|
UpdateStudioRenderConfig();
|
|
g_pStudioRender->BeginFrame();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 = cl.GetFrameTime();
|
|
if ( m_framerate > 0 )
|
|
{
|
|
m_framerate = 1 / m_framerate;
|
|
}
|
|
|
|
g_pStudioRender->EndFrame();
|
|
}
|
|
|
|
|
|
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( g_MainViewOrigin, view.origin ) )
|
|
{
|
|
LeafVisBuild( view.origin );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clear the view (assumes the render target has already been pushed)
|
|
//-----------------------------------------------------------------------------
|
|
void CRender::ClearView( 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;
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
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( const CViewSetup &view, int nFlags, ITexture* pRenderTarget, Frustum frustumPlanes )
|
|
{
|
|
Push3DView( view, nFlags, pRenderTarget, frustumPlanes, NULL );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes view matrices
|
|
//-----------------------------------------------------------------------------
|
|
float ComputeViewMatrices( VMatrix *pWorldToView, VMatrix *pViewToProjection, VMatrix *pWorldToProjection, const CViewSetup &viewSetup )
|
|
{
|
|
float flAspectRatio = viewSetup.m_flAspectRatio;
|
|
if ( flAspectRatio == 0.0f )
|
|
{
|
|
flAspectRatio = (viewSetup.height != 0) ? ( (float)viewSetup.width / (float)viewSetup.height ) : 1.0f;
|
|
}
|
|
|
|
ComputeViewMatrix( pWorldToView, viewSetup.origin, viewSetup.angles );
|
|
|
|
if ( viewSetup.m_bOrtho )
|
|
{
|
|
MatrixBuildOrtho( *pViewToProjection, viewSetup.m_OrthoLeft, viewSetup.m_OrthoTop,
|
|
viewSetup.m_OrthoRight, viewSetup.m_OrthoBottom, viewSetup.zNear, viewSetup.zFar );
|
|
}
|
|
else if ( viewSetup.m_bOffCenter ) // Off-center projection, useful for AA jitter and tiled output of posters
|
|
{
|
|
MatrixBuildPerspectiveOffCenterX( *pViewToProjection, viewSetup.fov, flAspectRatio,
|
|
viewSetup.zNear, viewSetup.zFar, viewSetup.m_flOffCenterBottom, viewSetup.m_flOffCenterTop,
|
|
viewSetup.m_flOffCenterLeft, viewSetup.m_flOffCenterRight );
|
|
}
|
|
else if ( viewSetup.m_bViewToProjectionOverride )
|
|
{
|
|
*pViewToProjection = viewSetup.m_ViewToProjection;
|
|
// ...but then override the Z range (needed for correct skybox rendering, etc).
|
|
MatrixBuildPerspectiveZRange ( *pViewToProjection, viewSetup.zNear, viewSetup.zFar );
|
|
}
|
|
else
|
|
{
|
|
MatrixBuildPerspectiveX( *pViewToProjection, viewSetup.fov, flAspectRatio, viewSetup.zNear, viewSetup.zFar );
|
|
}
|
|
|
|
MatrixMultiply( *pViewToProjection, *pWorldToView, *pWorldToProjection );
|
|
|
|
return flAspectRatio;
|
|
}
|
|
|
|
|
|
|
|
// 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( 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 = ComputeViewMatrices( &viewStack.m_matrixView,
|
|
&viewStack.m_matrixProjection, &viewStack.m_matrixWorldToScreen, topView );
|
|
|
|
m_zNear = topView.zNear;
|
|
m_zFar = topView.zFar; // cache this for queries
|
|
|
|
ExtractMatrices();
|
|
|
|
if ( !m_ViewStack[i].m_bNoDraw )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
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( 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( 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;
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
if ( !pRenderContext )
|
|
{
|
|
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( 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( Frustum frustumPlanes )
|
|
{
|
|
if ( !m_ViewStack.Top().m_bNoDraw )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
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();
|
|
OnViewActive( frustumPlanes );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the main 3D view (for console commands, sound, etc.)
|
|
//-----------------------------------------------------------------------------
|
|
void CRender::SetMainView( const Vector &vecOrigin, const QAngle &angles )
|
|
{
|
|
VectorCopy( vecOrigin, g_MainViewOrigin );
|
|
AngleVectors( angles, &g_MainViewForward, &g_MainViewRight, &g_MainViewUp );
|
|
}
|
|
|
|
CUtlVector<LightmapUpdateInfo_t> g_LightmapUpdateList;
|
|
CUtlVector<LightmapTransformInfo_t> g_LightmapTransformList;
|
|
|
|
int __cdecl LightmapPageCompareFunc( const void *pElem0, const void *pElem1 )
|
|
{
|
|
const LightmapUpdateInfo_t *pSurf0 = (const LightmapUpdateInfo_t *)pElem0;
|
|
const LightmapUpdateInfo_t *pSurf1 = (const LightmapUpdateInfo_t *)pElem1;
|
|
int page0 = materialSortInfoArray[MSurf_MaterialSortID( (pSurf0->m_SurfHandle) )].lightmapPageID;
|
|
int page1 = materialSortInfoArray[MSurf_MaterialSortID( (pSurf1->m_SurfHandle) )].lightmapPageID;
|
|
return page0 - page1;
|
|
}
|
|
|
|
void CRender::BeginUpdateLightmaps( void )
|
|
{
|
|
if ( ++m_iLightmapUpdateDepth == 1)
|
|
{
|
|
Assert( g_LightmapUpdateList.Count() == 0 );
|
|
materials->BeginUpdateLightmaps();
|
|
// UNDONE: Move this to an init or constructor?
|
|
g_LightmapTransformList.RemoveAll();
|
|
int index = g_LightmapTransformList.AddToTail();
|
|
g_LightmapTransformList[index].pModel = host_state.worldmodel;
|
|
SetIdentityMatrix( g_LightmapTransformList[index].xform );
|
|
}
|
|
}
|
|
|
|
void CRender::UpdateBrushModelLightmap( model_t *model, IClientRenderable *pRenderable )
|
|
{
|
|
AssertOnce( m_iLightmapUpdateDepth );
|
|
|
|
if( !r_drawbrushmodels.GetBool() || !m_iLightmapUpdateDepth )
|
|
return;
|
|
|
|
R_MarkDlightsOnBrushModel( model, pRenderable );
|
|
if ( model->flags & MODELFLAG_HAS_DLIGHT )
|
|
{
|
|
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) )
|
|
{
|
|
LightmapUpdateInfo_t tmp;
|
|
tmp.m_SurfHandle = surfID;
|
|
tmp.transformIndex = transformIndex;
|
|
g_LightmapUpdateList.AddToTail( tmp );
|
|
bLight = true;
|
|
}
|
|
}
|
|
if ( !bLight )
|
|
{
|
|
model->flags &= ~MODELFLAG_HAS_DLIGHT; // don't need to check again unless a dlight hits us
|
|
}
|
|
}
|
|
}
|
|
|
|
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() )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
ICallQueue *pCallQueue = pRenderContext->GetCallQueue();
|
|
dlight_t *pLights = &cl_dlights[0];
|
|
// only do the copy when there are valid dlights to process and threading is on
|
|
if ( g_bActiveDlights && pCallQueue )
|
|
{
|
|
// keep a copy of the current dlight state around for the thread to work on
|
|
// in parallel. This way the main thread can continue to modify this state without
|
|
// generating any bad results
|
|
static dlight_t threadDlights[MAX_DLIGHTS*2];
|
|
static int threadFrameCount = 0;
|
|
pLights = &threadDlights[MAX_DLIGHTS*threadFrameCount];
|
|
Q_memcpy( pLights, cl_dlights, sizeof(dlight_t) * MAX_DLIGHTS );
|
|
threadFrameCount = (threadFrameCount+1) & 1;
|
|
}
|
|
|
|
qsort( g_LightmapUpdateList.Base(), g_LightmapUpdateList.Count(), sizeof(g_LightmapUpdateList.Element(0)), LightmapPageCompareFunc );
|
|
int i;
|
|
for ( i = g_LightmapUpdateList.Count()-1; i >= 0; --i )
|
|
{
|
|
const LightmapUpdateInfo_t &lightmapUpdateInfo = g_LightmapUpdateList.Element(i);
|
|
// a surface can get queued more than once if it's visible in multiple views (e.g. water reflection can do this)
|
|
// so check frame to make sure we only recompute once
|
|
if ( SurfaceLighting(lightmapUpdateInfo.m_SurfHandle)->m_nLastComputedFrame != r_framecount )
|
|
{
|
|
R_RenderDynamicLightmaps( pLights, pCallQueue, lightmapUpdateInfo.m_SurfHandle, g_LightmapTransformList[lightmapUpdateInfo.transformIndex].xform );
|
|
}
|
|
}
|
|
}
|
|
materials->EndUpdateLightmaps();
|
|
g_LightmapUpdateList.RemoveAll();
|
|
g_LightmapTransformList.RemoveAll();
|
|
}
|
|
}
|
|
|
|
bool CRender::InLightmapUpdate( void ) const
|
|
{
|
|
return ( m_iLightmapUpdateDepth != 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute the scene coordinates of a point in 3D
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender::ClipTransformWithProjection ( const VMatrix& worldToScreen, const Vector& point, Vector* pClip )
|
|
{
|
|
// UNDONE: Clean this up some, handle off-screen vertices
|
|
float w;
|
|
|
|
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;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute the scene coordinates of a point in 3D using the current engine's projection
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender::ClipTransform ( const Vector& point, Vector* pClip )
|
|
{
|
|
const VMatrix &worldToScreen = g_EngineRenderer->WorldToScreenMatrix();
|
|
return CRender::ClipTransformWithProjection ( worldToScreen, point, pClip );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 )
|
|
{
|
|
if ( !color || !color[3] )
|
|
return;
|
|
|
|
if( !pFadeMaterial )
|
|
return;
|
|
|
|
const CViewSetup &view = CurrentView();
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
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;
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->Scale( 1, -1, 1 );
|
|
pRenderContext->Ortho( 0, 0, view.width, view.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 );
|
|
|
|
float flOffset = 0.5f;
|
|
|
|
// Note - the viewport has already adjusted the origin
|
|
float x1=0.0f - flOffset;
|
|
float x2=view.width - flOffset;
|
|
float y1=0.0f - flOffset;
|
|
float y2=view.height - flOffset;
|
|
|
|
// adjust nominal uvs to reflect adjusted xys
|
|
float u1=FLerp(flUOffset, 1-flUOffset,view.x,view.x+view.width,x1);
|
|
float u2=FLerp(flUOffset, 1-flUOffset,view.x,view.x+view.width,x2);
|
|
float v1=FLerp(flVOffset, 1-flVOffset,view.y,view.y+view.height,y1);
|
|
float v2=FLerp(flVOffset, 1-flVOffset,view.y,view.y+view.height,y2);
|
|
|
|
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 );
|
|
}
|
|
|
|
void CRender::ExtractFrustumPlanes( Frustum frustumPlanes )
|
|
{
|
|
const CViewSetup &view = CurrentView();
|
|
|
|
GeneratePerspectiveFrustum( CurrentViewOrigin(),
|
|
CurrentViewForward(), CurrentViewRight(), CurrentViewUp(),
|
|
view.zNear, view.zFar, view.fov, m_yFOV, g_Frustum );
|
|
|
|
// Copy out to the planes that the engine renderer uses.
|
|
for( int i=0; i < FRUSTUM_NUMPLANES; i++ )
|
|
{
|
|
frustumPlanes[i].m_Normal = g_Frustum.GetPlane(i)->normal;
|
|
frustumPlanes[i].m_Dist = g_Frustum.GetPlane(i)->dist;
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
// Copy out to the planes that the engine renderer uses.
|
|
for(int i=0; i < FRUSTUM_NUMPLANES; i++)
|
|
{
|
|
/*
|
|
if (fabs(frustumPlanes[i].m_Normal.x) - 1.0f > -1e-3)
|
|
frustum[i].type = PLANE_X;
|
|
else if (fabs(frustumPlanes[i].m_Normal.y) - 1.0f > -1e-3)
|
|
frustum[i].type = PLANE_Y;
|
|
else if (fabs(frustumPlanes[i].m_Normal.z) - 1.0f > -1e-3)
|
|
frustum[i].type = PLANE_Z;
|
|
else
|
|
*/
|
|
g_Frustum.SetPlane( i, PLANE_ANYZ, frustumPlanes[i].m_Normal, frustumPlanes[i].m_Dist );
|
|
}
|
|
}
|
|
|
|
void CRender::OverrideViewFrustum( Frustum custom )
|
|
{
|
|
// Copy out to the planes that the engine renderer uses.
|
|
for( int i = 0; i != FRUSTUM_NUMPLANES; ++i )
|
|
{
|
|
g_Frustum.SetPlane( i, PLANE_ANYZ, custom[i].m_Normal, custom[i].m_Dist );
|
|
}
|
|
}
|
|
|
|
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 ComputeViewMatrix( VMatrix *pViewMatrix, const Vector &origin, const QAngle &angles )
|
|
{
|
|
static VMatrix baseRotation;
|
|
static bool bDidInit;
|
|
|
|
if ( !bDidInit )
|
|
{
|
|
MatrixBuildRotationAboutAxis( baseRotation, Vector( 1, 0, 0 ), -90 );
|
|
MatrixRotate( baseRotation, Vector( 0, 0, 1 ), 90 );
|
|
bDidInit = true;
|
|
}
|
|
|
|
*pViewMatrix = baseRotation;
|
|
MatrixRotate( *pViewMatrix, Vector( 1, 0, 0 ), -angles[2] );
|
|
MatrixRotate( *pViewMatrix, Vector( 0, 1, 0 ), -angles[0] );
|
|
MatrixRotate( *pViewMatrix, Vector( 0, 0, 1 ), -angles[1] );
|
|
|
|
MatrixTranslate( *pViewMatrix, -origin );
|
|
}
|
|
|
|
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 );
|
|
|
|
#ifndef _XBOX
|
|
int x = 0;
|
|
int y = 0;
|
|
#else
|
|
// xboxissue - border safe
|
|
int x = 32;
|
|
int y = 32;
|
|
#endif
|
|
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()
|
|
{
|
|
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
|
|
|
|
UpdateStudioRenderConfig();
|
|
UpdateMaterialSystemConfig();
|
|
if( MaterialConfigLightingChanged() || g_RebuildLightmaps )
|
|
{
|
|
ClearMaterialConfigLightingChanged();
|
|
ConMsg( "Redownloading all lightmaps\n" );
|
|
BuildGammaTable( 2.2f, 2.2f, 0.0f, OVERBRIGHT );
|
|
R_RedownloadAllLightmaps();
|
|
StaticPropMgr()->RecomputeStaticLighting();
|
|
}
|
|
}
|
|
|
|
void CRender::DrawSceneBegin( void )
|
|
{
|
|
R_CheckForLightingConfigChanges();
|
|
}
|
|
|
|
void CRender::DrawSceneEnd( void )
|
|
{
|
|
R_SceneEnd();
|
|
LeafVisDraw();
|
|
}
|
|
|
|
IWorldRenderList * CRender::CreateWorldList()
|
|
{
|
|
return AllocWorldRenderList();
|
|
}
|
|
|
|
|
|
// 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 )
|
|
{
|
|
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 );
|
|
}
|
|
|
|
void CRender::DrawWorldLists( IWorldRenderList *pList, unsigned long flags, float flWaterZAdjust )
|
|
{
|
|
Assert( pList );
|
|
R_DrawWorldLists( pList, flags, flWaterZAdjust );
|
|
}
|