BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/engine/r_areaportal.cpp

706 lines
22 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "render_pch.h"
#include "client.h"
#include "debug_leafvis.h"
#include "con_nprint.h"
#include "tier0/fasttimer.h"
#include "r_areaportal.h"
#include "cmodel_engine.h"
#include "con_nprint.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar r_ClipAreaPortals( "r_ClipAreaPortals", "1", FCVAR_CHEAT );
ConVar r_DrawPortals( "r_DrawPortals", "0", FCVAR_CHEAT );
CUtlVector<CPortalRect> g_PortalRects;
static bool g_bViewerInSolidSpace = false;
// ------------------------------------------------------------------------------------ //
// Classes.
// ------------------------------------------------------------------------------------ //
#define MAX_PORTAL_VERTS 32
class CAreaCullInfo
{
public:
CAreaCullInfo()
{
m_GlobalCounter = 0;
memset( &m_Frustum, 0, sizeof( m_Frustum ) );
memset( &m_Rect, 0, sizeof( m_Rect ) );
}
Frustum_t m_Frustum;
CPortalRect m_Rect;
unsigned short m_GlobalCounter; // Used to tell if it's been touched yet this frame.
};
// ------------------------------------------------------------------------------------ //
// Globals.
// ------------------------------------------------------------------------------------ //
// Visible areas from the client DLL + occluded areas using area portals.
unsigned char g_RenderAreaBits[32];
// Used to prevent it from coming back into portals while flowing through them.
static unsigned char g_AreaStack[32];
// Frustums for each area for the current frame. Used to cull out leaves.
static CUtlVector<CAreaCullInfo> g_AreaCullInfo;
// List of areas marked visible this frame.
static unsigned short g_VisibleAreas[MAX_MAP_AREAS];
static int g_nVisibleAreas;
// Tied to CAreaCullInfo::m_GlobalCounter.
static unsigned short g_GlobalCounter = 1;
// A copy of the current view setup, but possibly nobbled a bit.
static CViewSetup g_viewSetup;
static CPortalRect g_viewWindow;
// Maps from world space to normalised (-1,1) screen coords.
static VMatrix g_ScreenFromWorldProjection;
// ------------------------------------------------------------------------------------ //
// Functions.
// ------------------------------------------------------------------------------------ //
void R_Areaportal_LevelInit()
{
g_AreaCullInfo.SetCount( host_state.worldbrush->m_nAreas );
}
void R_Areaportal_LevelShutdown()
{
g_AreaCullInfo.Purge();
g_PortalRects.Purge();
}
static inline void R_SetBit( unsigned char *pBits, int bit )
{
pBits[bit>>3] |= (1 << (bit&7));
}
static inline void R_ClearBit( unsigned char *pBits, int bit )
{
pBits[bit>>3] &= ~(1 << (bit&7));
}
static inline unsigned char R_TestBit( unsigned char *pBits, int bit )
{
return pBits[bit>>3] & (1 << (bit&7));
}
struct portalclip_t
{
portalclip_t()
{
lists[0] = v0;
lists[1] = v1;
}
Vector v0[MAX_PORTAL_VERTS];
Vector v1[MAX_PORTAL_VERTS];
Vector *lists[2];
};
// Transforms and clips the portal's verts to the view frustum. Returns false
// if the verts lie outside the frustum.
static inline bool GetPortalScreenExtents( dareaportal_t *pPortal,
portalclip_t * RESTRICT clip, CPortalRect &portalRect , float *pReflectionWaterHeight )
{
portalRect.left = portalRect.bottom = 1e24;
portalRect.right = portalRect.top = -1e24;
bool bValidExtents = false;
worldbrushdata_t *pBrushData = host_state.worldbrush;
int nStartVerts = min( (int)pPortal->m_nClipPortalVerts, MAX_PORTAL_VERTS );
// NOTE: We need two passes to deal with reflection. We need to compute
// the screen extents for both the reflected + non-reflected area portals
// and make bounds that surrounds them both.
int nPassCount = ( pReflectionWaterHeight != NULL ) ? 2 : 1;
for ( int j = 0; j < nPassCount; ++j )
{
int i;
for( i=0; i < nStartVerts; i++ )
{
clip->v0[i] = pBrushData->m_pClipPortalVerts[pPortal->m_FirstClipPortalVert+i];
// 2nd pass is to compute the reflected areaportal position
if ( j == 1 )
{
clip->v0[i].z = 2.0f * ( *pReflectionWaterHeight ) - clip->v0[i].z;
}
}
int iCurList = 0;
bool bAllClipped = false;
for( int iPlane=0; iPlane < 4; iPlane++ )
{
const cplane_t *pPlane = g_Frustum.GetPlane(iPlane);
Vector *pIn = clip->lists[iCurList];
Vector *pOut = clip->lists[!iCurList];
int nOutVerts = 0;
int iPrev = nStartVerts - 1;
float flPrevDot = pPlane->normal.Dot( pIn[iPrev] ) - pPlane->dist;
for( int iCur=0; iCur < nStartVerts; iCur++ )
{
float flCurDot = pPlane->normal.Dot( pIn[iCur] ) - pPlane->dist;
if( (flCurDot > 0) != (flPrevDot > 0) )
{
if( nOutVerts < MAX_PORTAL_VERTS )
{
// Add the vert at the intersection.
float t = flPrevDot / (flPrevDot - flCurDot);
VectorLerp( pIn[iPrev], pIn[iCur], t, pOut[nOutVerts] );
++nOutVerts;
}
}
// Add this vert?
if( flCurDot > 0 )
{
if( nOutVerts < MAX_PORTAL_VERTS )
{
pOut[nOutVerts] = pIn[iCur];
++nOutVerts;
}
}
flPrevDot = flCurDot;
iPrev = iCur;
}
if( nOutVerts == 0 )
{
// If they're all behind, then this portal is clipped out.
bAllClipped = true;
break;
}
nStartVerts = nOutVerts;
iCurList = !iCurList;
}
if ( bAllClipped )
continue;
// Project all the verts and figure out the screen extents.
Vector screenPos;
Assert( iCurList == 0 );
for( i=0; i < nStartVerts; i++ )
{
Vector &point = clip->v0[i];
g_EngineRenderer->ClipTransformWithProjection ( g_ScreenFromWorldProjection, point, &screenPos );
portalRect.left = fpmin( screenPos.x, portalRect.left );
portalRect.bottom = fpmin( screenPos.y, portalRect.bottom );
portalRect.top = fpmax( screenPos.y, portalRect.top );
portalRect.right = fpmax( screenPos.x, portalRect.right );
}
bValidExtents = true;
}
if ( !bValidExtents )
{
portalRect.left = portalRect.bottom = 0;
portalRect.right = portalRect.top = 0;
}
return bValidExtents;
}
// Fill in the intersection between the two rectangles.
inline bool GetRectIntersection( CPortalRect const *pRect1, CPortalRect const *pRect2, CPortalRect *pOut )
{
pOut->left = fpmax( pRect1->left, pRect2->left );
pOut->right = fpmin( pRect1->right, pRect2->right );
if( pOut->left >= pOut->right )
return false;
pOut->bottom = fpmax( pRect1->bottom, pRect2->bottom );
pOut->top = fpmin( pRect1->top, pRect2->top );
if( pOut->bottom >= pOut->top )
return false;
return true;
}
static void R_FlowThroughArea( int area, const Vector &vecVisOrigin, const CPortalRect *pClipRect,
const VisOverrideData_t* pVisData, float *pReflectionWaterHeight )
{
#ifndef SWDS
// Update this area's frustum.
if( g_AreaCullInfo[area].m_GlobalCounter != g_GlobalCounter )
{
g_VisibleAreas[g_nVisibleAreas] = area;
++g_nVisibleAreas;
g_AreaCullInfo[area].m_GlobalCounter = g_GlobalCounter;
g_AreaCullInfo[area].m_Rect = *pClipRect;
}
else
{
// Expand the areaportal's rectangle to include the new cliprect.
CPortalRect *pFrustumRect = &g_AreaCullInfo[area].m_Rect;
pFrustumRect->left = fpmin( pFrustumRect->left, pClipRect->left );
pFrustumRect->bottom = fpmin( pFrustumRect->bottom, pClipRect->bottom );
pFrustumRect->top = fpmax( pFrustumRect->top, pClipRect->top );
pFrustumRect->right = fpmax( pFrustumRect->right, pClipRect->right );
}
// Mark this area as visible.
R_SetBit( g_RenderAreaBits, area );
// Set that we're in this area on the stack.
R_SetBit( g_AreaStack, area );
worldbrushdata_t *pBrushData = host_state.worldbrush;
Assert( area < host_state.worldbrush->m_nAreas );
darea_t *pArea = &host_state.worldbrush->m_pAreas[area];
// temp buffer for clipping
portalclip_t clipTmp;
// Check all areas that connect to this area.
for( int iAreaPortal=0; iAreaPortal < pArea->numareaportals; iAreaPortal++ )
{
Assert( pArea->firstareaportal + iAreaPortal < pBrushData->m_nAreaPortals );
dareaportal_t *pAreaPortal = &pBrushData->m_pAreaPortals[ pArea->firstareaportal + iAreaPortal ];
// Don't flow back into a portal on the stack.
if( R_TestBit( g_AreaStack, pAreaPortal->otherarea ) )
continue;
// If this portal is closed, don't go through it.
if ( !R_TestBit( cl.m_chAreaPortalBits, pAreaPortal->m_PortalKey ) )
continue;
// Make sure the viewer is on the right side of the portal to see through it.
cplane_t *pPlane = &pBrushData->planes[ pAreaPortal->planenum ];
// Use the specified vis origin to test backface culling, or the main view if none was specified
float flDist = pPlane->normal.Dot( vecVisOrigin ) - pPlane->dist;
if( flDist < -0.1f )
continue;
// If the client doesn't want this area visible, don't try to flow into it.
if( !R_TestBit( cl.m_chAreaBits, pAreaPortal->otherarea ) )
continue;
CPortalRect portalRect;
bool portalVis = true;
// don't try to clip portals if the viewer is practically in the plane
float fDistTolerance = (pVisData)?(pVisData->m_fDistToAreaPortalTolerance):(0.1f);
if ( flDist > fDistTolerance )
{
portalVis = GetPortalScreenExtents( pAreaPortal, &clipTmp, portalRect, pReflectionWaterHeight );
}
else
{
portalRect.left = -1;
portalRect.top = 1;
portalRect.right = 1;
portalRect.bottom = -1; // note top/bottom reversed!
//portalVis=true - not needed, default
}
if( portalVis )
{
CPortalRect intersection;
if( GetRectIntersection( &portalRect, pClipRect, &intersection ) )
{
#ifdef USE_CONVARS
if( r_DrawPortals.GetInt() )
{
g_PortalRects.AddToTail( intersection );
}
#endif
// Ok, we can see into this area.
R_FlowThroughArea( pAreaPortal->otherarea, vecVisOrigin, &intersection, pVisData, pReflectionWaterHeight );
}
}
}
// Mark that we're leaving this area.
R_ClearBit( g_AreaStack, area );
#endif
}
static void IncrementGlobalCounter()
{
if( g_GlobalCounter == 0xFFFF )
{
for( int i=0; i < g_AreaCullInfo.Count(); i++ )
g_AreaCullInfo[i].m_GlobalCounter = 0;
g_GlobalCounter = 1;
}
else
{
g_GlobalCounter++;
}
}
static void R_SetupGlobalFrustum()
{
#ifndef SWDS
// Copy the current view away so that we can play with it if needed.
g_viewSetup = g_EngineRenderer->ViewGetCurrent();
if( g_viewSetup.m_bOrtho )
{
g_viewWindow.right = g_viewSetup.m_OrthoRight;
g_viewWindow.left = g_viewSetup.m_OrthoLeft;
g_viewWindow.top = g_viewSetup.m_OrthoTop;
g_viewWindow.bottom = g_viewSetup.m_OrthoBottom;
}
else
{
// Assuming a view plane distance of 1, figure out the boundaries of a window
// the view would project into given the FOV.
float xFOV = g_EngineRenderer->GetFov() * 0.5f;
float yFOV = g_EngineRenderer->GetFovY() * 0.5f;
g_viewWindow.right = tan( DEG2RAD( xFOV ) );
g_viewWindow.left = -g_viewWindow.right;
g_viewWindow.top = tan( DEG2RAD( yFOV ) );
g_viewWindow.bottom = -g_viewWindow.top;
if ( g_viewSetup.m_bOffCenter )
{
// How did this ever work?
Assert ( !"test m_bOffCenter frustums with area portals" );
}
else if ( g_viewSetup.m_bViewToProjectionOverride )
{
// ...this has been tested and works!
}
// Rather than try to deal with crazy projection matrices (shear, trapezoid, etc), take whatever FOV we're given,
// assume it's conservative, and then construct a matching projection matrix for it. Then use that consistent
// hallucination throughout, rather than refer back to the engine's actual proj. matrix for anything.
VMatrix matrixView;
VMatrix matrixProjection;
VMatrix matrixWorldToScreen;
g_viewSetup.m_bViewToProjectionOverride = false;
ComputeViewMatrices (
&matrixView,
&matrixProjection,
&matrixWorldToScreen,
g_viewSetup );
g_ScreenFromWorldProjection = matrixWorldToScreen;
}
#endif //#ifndef SWDS
}
ConVar r_snapportal( "r_snapportal", "-1" );
extern void CSGFrustum( Frustum_t &frustum );
static void R_SetupVisibleAreaFrustums()
{
#ifndef SWDS
// Now scale the portals as specified in the normalized view frustum (-1,-1,1,1)
// into our view window and generate planes out of that.
for( int i=0; i < g_nVisibleAreas; i++ )
{
CAreaCullInfo *pInfo = &g_AreaCullInfo[ g_VisibleAreas[i] ];
CPortalRect portalWindow;
portalWindow.left = RemapVal( pInfo->m_Rect.left, -1, 1, g_viewWindow.left, g_viewWindow.right );
portalWindow.right = RemapVal( pInfo->m_Rect.right, -1, 1, g_viewWindow.left, g_viewWindow.right );
portalWindow.top = RemapVal( pInfo->m_Rect.top, -1, 1, g_viewWindow.bottom, g_viewWindow.top );
portalWindow.bottom = RemapVal( pInfo->m_Rect.bottom, -1, 1, g_viewWindow.bottom, g_viewWindow.top );
if( g_viewSetup.m_bOrtho )
{
// Left and right planes...
float orgOffset = DotProduct(CurrentViewOrigin(), CurrentViewRight());
pInfo->m_Frustum.SetPlane( FRUSTUM_LEFT, PLANE_ANYZ, CurrentViewRight(), portalWindow.left + orgOffset );
pInfo->m_Frustum.SetPlane( FRUSTUM_RIGHT, PLANE_ANYZ, -CurrentViewRight(), -portalWindow.right - orgOffset );
// Top and bottom planes...
orgOffset = DotProduct(CurrentViewOrigin(), CurrentViewUp());
pInfo->m_Frustum.SetPlane( FRUSTUM_TOP, PLANE_ANYZ, CurrentViewUp(), portalWindow.top + orgOffset );
pInfo->m_Frustum.SetPlane( FRUSTUM_BOTTOM, PLANE_ANYZ, -CurrentViewUp(), -portalWindow.bottom - orgOffset );
}
else
{
if ( g_viewSetup.m_bOffCenter )
{
// How did this ever work?
Assert ( !"test m_bOffCenter frustums with area portals" );
}
else if ( g_viewSetup.m_bViewToProjectionOverride )
{
// ...this has been tested and works!
}
Vector normal;
const cplane_t *pTest;
// right side
normal = portalWindow.right * CurrentViewForward() - CurrentViewRight();
VectorNormalize(normal); // OPTIMIZE: This is unnecessary for culling
pTest = pInfo->m_Frustum.GetPlane( FRUSTUM_RIGHT );
pInfo->m_Frustum.SetPlane( FRUSTUM_RIGHT, PLANE_ANYZ, normal, DotProduct(normal,CurrentViewOrigin()) );
// left side
normal = CurrentViewRight() - portalWindow.left * CurrentViewForward();
VectorNormalize(normal); // OPTIMIZE: This is unnecessary for culling
pTest = pInfo->m_Frustum.GetPlane( FRUSTUM_LEFT );
pInfo->m_Frustum.SetPlane( FRUSTUM_LEFT, PLANE_ANYZ, normal, DotProduct(normal,CurrentViewOrigin()) );
// top
normal = portalWindow.top * CurrentViewForward() - CurrentViewUp();
VectorNormalize(normal); // OPTIMIZE: This is unnecessary for culling
pTest = pInfo->m_Frustum.GetPlane( FRUSTUM_TOP );
pInfo->m_Frustum.SetPlane( FRUSTUM_TOP, PLANE_ANYZ, normal, DotProduct(normal,CurrentViewOrigin()) );
// bottom
normal = CurrentViewUp() - portalWindow.bottom * CurrentViewForward();
VectorNormalize(normal); // OPTIMIZE: This is unnecessary for culling
pTest = pInfo->m_Frustum.GetPlane( FRUSTUM_BOTTOM );
pInfo->m_Frustum.SetPlane( FRUSTUM_BOTTOM, PLANE_ANYZ, normal, DotProduct(normal,CurrentViewOrigin()) );
// farz
pInfo->m_Frustum.SetPlane( FRUSTUM_FARZ, PLANE_ANYZ, -CurrentViewForward(),
DotProduct(-CurrentViewForward(), CurrentViewOrigin() + CurrentViewForward()*g_viewSetup.zFar) );
}
// DEBUG: Code to visualize the areaportal frustums in 3D
// Useful for debugging
extern void CSGFrustum( Frustum_t &frustum );
if ( r_snapportal.GetInt() >= 0 )
{
if ( g_VisibleAreas[i] == r_snapportal.GetInt() )
{
pInfo->m_Frustum.SetPlane( FRUSTUM_NEARZ, PLANE_ANYZ, CurrentViewForward(),
DotProduct(CurrentViewForward(), CurrentViewOrigin()) );
pInfo->m_Frustum.SetPlane( FRUSTUM_FARZ, PLANE_ANYZ, -CurrentViewForward(),
DotProduct(-CurrentViewForward(), CurrentViewOrigin() + CurrentViewForward()*500) );
r_snapportal.SetValue( -1 );
CSGFrustum( pInfo->m_Frustum );
}
}
}
#endif
}
// Intersection of AABB and a frustum. The frustum may contain 0-32 planes
// (active planes are defined by inClipMask). Returns boolean value indicating
// whether AABB intersects the view frustum or not.
// If AABB intersects the frustum, an output clip mask is returned as well
// (indicating which planes are crossed by the AABB). This information
// can be used to optimize testing of child nodes or objects inside the
// nodes (pass value as 'inClipMask').
inline bool R_CullNodeInternal( mnode_t *pNode, int &nClipMask, const Frustum_t& frustum )
{
int nOutClipMask = nClipMask & FRUSTUM_CLIP_IN_AREA; // init outclip mask
float flCenterDotNormal, flHalfDiagDotAbsNormal;
if (nClipMask & FRUSTUM_CLIP_RIGHT)
{
const cplane_t *pPlane = frustum.GetPlane(FRUSTUM_RIGHT);
flCenterDotNormal = DotProduct( pNode->m_vecCenter, pPlane->normal ) - pPlane->dist;
flHalfDiagDotAbsNormal = DotProduct( pNode->m_vecHalfDiagonal, frustum.GetAbsNormal(FRUSTUM_RIGHT) );
if (flCenterDotNormal + flHalfDiagDotAbsNormal < 0.0f)
return true;
if (flCenterDotNormal - flHalfDiagDotAbsNormal < 0.0f)
nOutClipMask |= FRUSTUM_CLIP_RIGHT;
}
if (nClipMask & FRUSTUM_CLIP_LEFT)
{
const cplane_t *pPlane = frustum.GetPlane(FRUSTUM_LEFT);
flCenterDotNormal = DotProduct( pNode->m_vecCenter, pPlane->normal ) - pPlane->dist;
flHalfDiagDotAbsNormal = DotProduct( pNode->m_vecHalfDiagonal, frustum.GetAbsNormal(FRUSTUM_LEFT) );
if (flCenterDotNormal + flHalfDiagDotAbsNormal < 0.0f)
return true;
if (flCenterDotNormal - flHalfDiagDotAbsNormal < 0.0f)
nOutClipMask |= FRUSTUM_CLIP_LEFT;
}
if (nClipMask & FRUSTUM_CLIP_TOP)
{
const cplane_t *pPlane = frustum.GetPlane(FRUSTUM_TOP);
flCenterDotNormal = DotProduct( pNode->m_vecCenter, pPlane->normal ) - pPlane->dist;
flHalfDiagDotAbsNormal = DotProduct( pNode->m_vecHalfDiagonal, frustum.GetAbsNormal(FRUSTUM_TOP) );
if (flCenterDotNormal + flHalfDiagDotAbsNormal < 0.0f)
return true;
if (flCenterDotNormal - flHalfDiagDotAbsNormal < 0.0f)
nOutClipMask |= FRUSTUM_CLIP_TOP;
}
if (nClipMask & FRUSTUM_CLIP_BOTTOM)
{
const cplane_t *pPlane = frustum.GetPlane(FRUSTUM_BOTTOM);
flCenterDotNormal = DotProduct( pNode->m_vecCenter, pPlane->normal ) - pPlane->dist;
flHalfDiagDotAbsNormal = DotProduct( pNode->m_vecHalfDiagonal, frustum.GetAbsNormal(FRUSTUM_BOTTOM) );
if (flCenterDotNormal + flHalfDiagDotAbsNormal < 0.0f)
return true;
if (flCenterDotNormal - flHalfDiagDotAbsNormal < 0.0f)
nOutClipMask |= FRUSTUM_CLIP_BOTTOM;
}
nClipMask = nOutClipMask;
return false; // AABB intersects frustum
}
bool R_CullNode( Frustum_t *pAreaFrustum, mnode_t *pNode, int& nClipMask )
{
// Now cull to this area's frustum.
if (( !g_bViewerInSolidSpace ) && ( pNode->area > 0 ))
{
// First make sure its whole area is even visible.
if( !R_IsAreaVisible( pNode->area ) )
return true;
// This ConVar access causes a huge perf hit in some cases.
// If you want to put it back in please cache it's value.
//#ifdef USE_CONVARS
// if( r_ClipAreaPortals.GetInt() )
//#else
if( 1 )
//#endif
{
if ((nClipMask & FRUSTUM_CLIP_IN_AREA) == 0)
{
// In this case, we've never hit this area before and
// we need to test all planes again because we just changed the frustum
nClipMask = FRUSTUM_CLIP_IN_AREA | FRUSTUM_CLIP_ALL;
}
pAreaFrustum = &g_AreaCullInfo[pNode->area].m_Frustum;
}
}
return R_CullNodeInternal( pNode, nClipMask, *pAreaFrustum );
}
static ConVar r_portalscloseall( "r_portalscloseall", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
static ConVar r_portalsopenall( "r_portalsopenall", "0", FCVAR_CHEAT, "Open all portals" );
static ConVar r_ShowViewerArea( "r_ShowViewerArea", "0" );
void R_SetupAreaBits( int iForceViewLeaf /* = -1 */, const VisOverrideData_t* pVisData /* = NULL */, float *pWaterReflectionHeight /* = NULL */ )
{
IncrementGlobalCounter();
g_bViewerInSolidSpace = false;
// Clear the visible area bits.
memset( g_RenderAreaBits, 0, sizeof( g_RenderAreaBits ) );
memset( g_AreaStack, 0, sizeof( g_AreaStack ) );
// Our initial clip rect is the whole screen.
CPortalRect rect;
rect.left = rect.bottom = -1;
rect.top = rect.right = 1;
// Flow through areas starting at the one we're in.
int leaf = iForceViewLeaf;
// If view point override wasn't specified, use the current view origin
if ( iForceViewLeaf == -1 )
{
leaf = CM_PointLeafnum( g_EngineRenderer->ViewOrigin() );
}
if( r_portalscloseall.GetBool() )
{
if ( cl.m_bAreaBitsValid )
{
// Clear the visible area bits.
memset( g_RenderAreaBits, 0, sizeof( g_RenderAreaBits ) );
int area = host_state.worldbrush->leafs[leaf].area;
R_SetBit( g_RenderAreaBits, area );
g_VisibleAreas[0] = area;
g_nVisibleAreas = 1;
g_AreaCullInfo[area].m_GlobalCounter = g_GlobalCounter;
g_AreaCullInfo[area].m_Rect = rect;
R_SetupVisibleAreaFrustums();
}
else
{
g_bViewerInSolidSpace = true;
}
return;
}
#if defined( REPLAY_ENABLED )
if ( host_state.worldbrush->leafs[leaf].contents & CONTENTS_SOLID ||
cl.ishltv || cl.isreplay || !cl.m_bAreaBitsValid || r_portalsopenall.GetBool() )
#else
if ( host_state.worldbrush->leafs[leaf].contents & CONTENTS_SOLID ||
cl.ishltv || !cl.m_bAreaBitsValid || r_portalsopenall.GetBool() )
#endif
{
// Draw everything if we're in solid space or if r_portalsopenall is true (used for building cubemaps)
g_bViewerInSolidSpace = true;
if ( r_ShowViewerArea.GetInt() )
Con_NPrintf( 3, "Viewer area: (solid space)" );
}
else
{
int area = host_state.worldbrush->leafs[leaf].area;
if ( r_ShowViewerArea.GetInt() )
Con_NPrintf( 3, "Viewer area: %d", area );
g_nVisibleAreas = 0;
Vector vecVisOrigin = (pVisData)?(pVisData->m_vecVisOrigin):(g_EngineRenderer->ViewOrigin());
R_SetupGlobalFrustum();
R_FlowThroughArea ( area, vecVisOrigin, &rect, pVisData, pWaterReflectionHeight );
R_SetupVisibleAreaFrustums();
}
}
const Frustum_t* GetAreaFrustum( int area )
{
if ( g_AreaCullInfo[area].m_GlobalCounter == g_GlobalCounter )
return &g_AreaCullInfo[area].m_Frustum;
else
return &g_Frustum;
}
Reference in New Issue View Git Blame Copy Permalink