1305 lines
48 KiB
C++
1305 lines
48 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "portalrenderable_flatbasic.h"
|
|
#include "clienteffectprecachesystem.h"
|
|
#include "Portal_DynamicMeshRenderingUtils.h"
|
|
#include "portal_shareddefs.h"
|
|
#include "view.h"
|
|
#include "c_pixel_visibility.h"
|
|
#include "glow_overlay.h"
|
|
#include "portal_render_targets.h"
|
|
#include "materialsystem/itexture.h"
|
|
#include "toolframework/itoolframework.h"
|
|
#include "toolframework_client.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "prop_portal_shared.h"
|
|
#include "view_scene.h"
|
|
#include "materialsystem/imaterialvar.h"
|
|
#include "tier0/vprof.h"
|
|
|
|
|
|
#define PORTALRENDERABLE_FLATBASIC_MINPIXELVIS 0.0f
|
|
|
|
|
|
CLIENTEFFECT_REGISTER_BEGIN( PrecacheFlatBasicPortalDrawingMaterials )
|
|
#if !defined( _X360 ) //XBox 360 is guaranteed to use stencil mode, and therefore doesn't need texture mode materials
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_1_dynamicmesh" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_2_dynamicmesh" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_1_renderfix_dynamicmesh" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_2_renderfix_dynamicmesh" )
|
|
#endif
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_depthdoubler" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portalstaticoverlay_1" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portalstaticoverlay_2" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_stencil_hole" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_refract_1" )
|
|
CLIENTEFFECT_MATERIAL( "models/portals/portal_refract_2" )
|
|
//CLIENTEFFECT_MATERIAL( "effects/flashlight001" ) //light transfers disabled indefinitely
|
|
CLIENTEFFECT_REGISTER_END()
|
|
|
|
class CAutoInitFlatBasicPortalDrawingMaterials : public CAutoGameSystem
|
|
{
|
|
public:
|
|
FlatBasicPortalRenderingMaterials_t m_Materials;
|
|
void LevelInitPreEntity()
|
|
{
|
|
m_Materials.m_PortalMaterials[0].Init( "models/portals/portal_1_dynamicmesh", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_PortalMaterials[1].Init( "models/portals/portal_2_dynamicmesh", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_PortalRenderFixMaterials[0].Init( "models/portals/portal_1_renderfix_dynamicmesh", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_PortalRenderFixMaterials[1].Init( "models/portals/portal_2_renderfix_dynamicmesh", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_PortalDepthDoubler.Init( "models/portals/portal_depthdoubler", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_PortalStaticOverlay[0].Init( "models/portals/portalstaticoverlay_1", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_PortalStaticOverlay[1].Init( "models/portals/portalstaticoverlay_2", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_Portal_Stencil_Hole.Init( "models/portals/portal_stencil_hole", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_Portal_Refract[0].Init( "models/portals/portal_refract_1", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
m_Materials.m_Portal_Refract[1].Init( "models/portals/portal_refract_2", TEXTURE_GROUP_CLIENT_EFFECTS );
|
|
//m_Materials.m_PortalLightTransfer_ShadowTexture.Init( "effects/flashlight001", TEXTURE_GROUP_OTHER ); //light transfers disabled indefinitely
|
|
|
|
m_Materials.m_pDepthDoubleViewMatrixVar = m_Materials.m_PortalDepthDoubler->FindVar( "$alternateviewmatrix", NULL, false );
|
|
Assert( m_Materials.m_pDepthDoubleViewMatrixVar != NULL );
|
|
}
|
|
};
|
|
static CAutoInitFlatBasicPortalDrawingMaterials s_FlatBasicPortalDrawingMaterials;
|
|
|
|
const FlatBasicPortalRenderingMaterials_t& CPortalRenderable_FlatBasic::m_Materials = s_FlatBasicPortalDrawingMaterials.m_Materials;
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( prop_portal_flatbasic, CPortalRenderable_FlatBasic );
|
|
|
|
|
|
CPortalRenderable_FlatBasic::CPortalRenderable_FlatBasic( void )
|
|
: m_pLinkedPortal( NULL ),
|
|
m_ptOrigin( 0.0f, 0.0f, 0.0f ),
|
|
m_vForward( 1.0f, 0.0f, 0.0f ),
|
|
m_vUp( 0.0f, 0.0f, 1.0f ),
|
|
m_vRight( 0.0f, 1.0f, 0.0f ),
|
|
m_fStaticAmount( 0.0f ),
|
|
m_fSecondaryStaticAmount( 0.0f ),
|
|
m_fOpenAmount( 0.0f ),
|
|
m_bIsPortal2( false )
|
|
{
|
|
m_InternallyMaintainedData.m_VisData.m_fDistToAreaPortalTolerance = 64.0f;
|
|
m_InternallyMaintainedData.m_VisData.m_vecVisOrigin = Vector(0,0,0);
|
|
m_InternallyMaintainedData.m_iViewLeaf = -1;
|
|
|
|
m_InternallyMaintainedData.m_DepthDoublerTextureView.Identity();
|
|
m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration = false;
|
|
m_InternallyMaintainedData.m_nSkyboxVisibleFromCorners = SKYBOX_NOT_VISIBLE;
|
|
|
|
m_InternallyMaintainedData.m_ptForwardOrigin.Init( 1.0f, 0.0f, 0.0f );
|
|
m_InternallyMaintainedData.m_ptCorners[0] =
|
|
m_InternallyMaintainedData.m_ptCorners[1] =
|
|
m_InternallyMaintainedData.m_ptCorners[2] =
|
|
m_InternallyMaintainedData.m_ptCorners[3] =
|
|
Vector( 0.0f, 0.0f, 0.0f );
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::GetToolRecordingState( bool bActive, KeyValues *msg )
|
|
{
|
|
if ( !ToolsEnabled() )
|
|
return;
|
|
|
|
VPROF_BUDGET( "CPortalRenderable_FlatBasic::GetToolRecordingState", VPROF_BUDGETGROUP_TOOLS );
|
|
|
|
BaseClass::GetToolRecordingState( msg );
|
|
CPortalRenderable::GetToolRecordingState( bActive, msg );
|
|
|
|
C_Prop_Portal *pLinkedPortal = static_cast<C_Prop_Portal*>( m_pLinkedPortal );
|
|
|
|
static PortalRecordingState_t state;
|
|
state.m_nPortalId = static_cast<C_Prop_Portal*>( this )->index;
|
|
state.m_nLinkedPortalId = pLinkedPortal ? pLinkedPortal->index : -1;
|
|
state.m_fStaticAmount = m_fStaticAmount;
|
|
state.m_fSecondaryStaticAmount = m_fSecondaryStaticAmount;
|
|
state.m_fOpenAmount = m_fOpenAmount;
|
|
state.m_bIsPortal2 = m_bIsPortal2;
|
|
msg->SetPtr( "portal", &state );
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::PortalMoved( void )
|
|
{
|
|
m_InternallyMaintainedData.m_ptForwardOrigin = m_ptOrigin + m_vForward;
|
|
m_InternallyMaintainedData.m_fPlaneDist = m_vForward.Dot( m_ptOrigin );
|
|
|
|
// Update the points on the portal which we add to PVS
|
|
{
|
|
Vector vScaledRight = m_vRight * PORTAL_HALF_WIDTH;
|
|
Vector vScaledUp = m_vUp * PORTAL_HALF_HEIGHT;
|
|
|
|
m_InternallyMaintainedData.m_ptCorners[0] = (m_InternallyMaintainedData.m_ptForwardOrigin + vScaledRight) + vScaledUp;
|
|
m_InternallyMaintainedData.m_ptCorners[1] = (m_InternallyMaintainedData.m_ptForwardOrigin - vScaledRight) + vScaledUp;
|
|
m_InternallyMaintainedData.m_ptCorners[2] = (m_InternallyMaintainedData.m_ptForwardOrigin - vScaledRight) - vScaledUp;
|
|
m_InternallyMaintainedData.m_ptCorners[3] = (m_InternallyMaintainedData.m_ptForwardOrigin + vScaledRight) - vScaledUp;
|
|
|
|
|
|
m_InternallyMaintainedData.m_VisData.m_vecVisOrigin = m_InternallyMaintainedData.m_ptForwardOrigin;
|
|
m_InternallyMaintainedData.m_VisData.m_fDistToAreaPortalTolerance = 64.0f;
|
|
m_InternallyMaintainedData.m_iViewLeaf = enginetrace->GetLeafContainingPoint( m_InternallyMaintainedData.m_ptForwardOrigin );
|
|
}
|
|
|
|
m_InternallyMaintainedData.m_nSkyboxVisibleFromCorners = engine->IsSkyboxVisibleFromPoint( m_InternallyMaintainedData.m_ptForwardOrigin );
|
|
for( int i = 0; i < 4 && ( m_InternallyMaintainedData.m_nSkyboxVisibleFromCorners != SKYBOX_3DSKYBOX_VISIBLE ); ++i )
|
|
{
|
|
SkyboxVisibility_t nCornerVis = engine->IsSkyboxVisibleFromPoint( m_InternallyMaintainedData.m_ptCorners[i] );
|
|
if ( ( m_InternallyMaintainedData.m_nSkyboxVisibleFromCorners == SKYBOX_NOT_VISIBLE ) || ( nCornerVis != SKYBOX_NOT_VISIBLE ) )
|
|
{
|
|
m_InternallyMaintainedData.m_nSkyboxVisibleFromCorners = nCornerVis;
|
|
}
|
|
}
|
|
|
|
//render fix bounding planes
|
|
{
|
|
for( int i = 0; i != PORTALRENDERFIXMESH_OUTERBOUNDPLANES; ++i )
|
|
{
|
|
float fCirclePos = ((float)(i)) * ((M_PI * 2.0f) / (float)PORTALRENDERFIXMESH_OUTERBOUNDPLANES);
|
|
float fUpBlend = cosf( fCirclePos );
|
|
float fRightBlend = sinf( fCirclePos );
|
|
|
|
Vector vNormal = -fUpBlend * m_vUp - fRightBlend * m_vRight;
|
|
Vector ptOnPlane = m_ptOrigin + (m_vUp * (fUpBlend * PORTAL_HALF_HEIGHT * 1.1f)) + (m_vRight * (fRightBlend * PORTAL_HALF_WIDTH * 1.1f));
|
|
|
|
m_InternallyMaintainedData.m_BoundingPlanes[i].Init( vNormal, vNormal.Dot( ptOnPlane ) );
|
|
}
|
|
|
|
m_InternallyMaintainedData.m_BoundingPlanes[PORTALRENDERFIXMESH_OUTERBOUNDPLANES].Init( -m_vForward, (-m_vForward).Dot( m_ptOrigin ) );
|
|
m_InternallyMaintainedData.m_BoundingPlanes[PORTALRENDERFIXMESH_OUTERBOUNDPLANES + 1].Init( m_vForward, m_vForward.Dot( m_ptOrigin - (m_vForward * 5.0f) ) );
|
|
}
|
|
|
|
//update depth doubler usability flag
|
|
m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration =
|
|
( m_pLinkedPortal && //linked to another portal
|
|
( m_vForward.Dot( m_pLinkedPortal->m_ptOrigin - m_ptOrigin ) > 0.0f ) && //this portal looking in the general direction of the other portal
|
|
( m_vForward.Dot( m_pLinkedPortal->m_vForward ) < -0.7071f ) ); //within 45 degrees of facing directly at each other
|
|
|
|
if( m_pLinkedPortal )
|
|
m_pLinkedPortal->m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration = true;
|
|
|
|
|
|
|
|
//lastly, update link matrix
|
|
if ( m_pLinkedPortal != NULL )
|
|
{
|
|
matrix3x4_t localToWorld( m_vForward, -m_vRight, m_vUp, m_ptOrigin );
|
|
matrix3x4_t remoteToWorld( m_pLinkedPortal->m_vForward, -m_pLinkedPortal->m_vRight, m_pLinkedPortal->m_vUp, m_pLinkedPortal->m_ptOrigin );
|
|
CProp_Portal_Shared::UpdatePortalTransformationMatrix( localToWorld, remoteToWorld, &m_matrixThisToLinked );
|
|
|
|
// update the remote portal
|
|
MatrixInverseTR( m_matrixThisToLinked, m_pLinkedPortal->m_matrixThisToLinked );
|
|
}
|
|
else
|
|
{
|
|
m_matrixThisToLinked.Identity(); // don't accidentally teleport objects to zero space
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CPortalRenderable_FlatBasic::WillUseDepthDoublerThisDraw( void ) const
|
|
{
|
|
return g_pPortalRender->ShouldUseStencilsToRenderPortals() &&
|
|
m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration &&
|
|
(g_pPortalRender->GetRemainingPortalViewDepth() == 0) &&
|
|
(g_pPortalRender->GetViewRecursionLevel() > 1) &&
|
|
(g_pPortalRender->GetCurrentViewExitPortal() != this);
|
|
}
|
|
|
|
|
|
|
|
ConVar r_portal_use_complex_frustums( "r_portal_use_complex_frustums", "1", FCVAR_CLIENTDLL, "View optimization, turn this off if you get odd visual bugs." );
|
|
|
|
bool CPortalRenderable_FlatBasic::CalcFrustumThroughPortal( const Vector &ptCurrentViewOrigin, Frustum OutputFrustum )
|
|
{
|
|
if( r_portal_use_complex_frustums.GetBool() == false )
|
|
return false;
|
|
|
|
int i;
|
|
|
|
int iViewRecursionLevel = g_pPortalRender->GetViewRecursionLevel();
|
|
int iNextViewRecursionLevel = iViewRecursionLevel + 1;
|
|
|
|
if( (iViewRecursionLevel == 0) &&
|
|
( (ptCurrentViewOrigin - m_ptOrigin).LengthSqr() < (PORTAL_HALF_HEIGHT * PORTAL_HALF_HEIGHT) ) )//FIXME: Player closeness check might need reimplementation
|
|
{
|
|
//calculations are most likely going to be completely useless, return nothing
|
|
return false;
|
|
}
|
|
|
|
if( m_pLinkedPortal == NULL )
|
|
return false;
|
|
|
|
if( m_vForward.Dot( ptCurrentViewOrigin ) <= m_InternallyMaintainedData.m_fPlaneDist )
|
|
return false; //looking at portal backface
|
|
|
|
//VPlane *pInputFrustum = view->GetFrustum(); //g_pPortalRender->m_RecursiveViewComplexFrustums[iViewRecursionLevel].Base();
|
|
//int iInputFrustumPlaneCount = 6; //g_pPortalRender->m_RecursiveViewComplexFrustums[iViewRecursionLevel].Count();
|
|
VPlane *pInputFrustum = g_pPortalRender->m_RecursiveViewComplexFrustums[iViewRecursionLevel].Base();
|
|
int iInputFrustumPlaneCount = g_pPortalRender->m_RecursiveViewComplexFrustums[iViewRecursionLevel].Count();
|
|
Assert( iInputFrustumPlaneCount > 0 );
|
|
|
|
Vector ptTempWork[2];
|
|
int iAllocSize = 4 + iInputFrustumPlaneCount;
|
|
|
|
Vector *pInVerts = (Vector *)stackalloc( sizeof( Vector ) * iAllocSize * 2 ); //possible to add 1 point per cut, 4 starting points, iInputFrustumPlaneCount cuts
|
|
Vector *pOutVerts = pInVerts + iAllocSize;
|
|
Vector *pTempVerts;
|
|
|
|
//clip by first plane and put output into pInVerts
|
|
int iVertCount = ClipPolyToPlane( m_InternallyMaintainedData.m_ptCorners, 4, pInVerts, pInputFrustum[0].m_Normal, pInputFrustum[0].m_Dist, 0.01f );
|
|
|
|
//clip by other planes and flipflop in and out pointers
|
|
for( i = 1; i != iInputFrustumPlaneCount; ++i )
|
|
{
|
|
if( iVertCount < 3 )
|
|
return false; //nothing left in the frustum
|
|
|
|
iVertCount = ClipPolyToPlane( pInVerts, iVertCount, pOutVerts, pInputFrustum[i].m_Normal, pInputFrustum[i].m_Dist, 0.01f );
|
|
pTempVerts = pInVerts; pInVerts = pOutVerts; pOutVerts = pTempVerts; //swap vertex pointers
|
|
}
|
|
|
|
if( iVertCount < 3 )
|
|
return false; //nothing left in the frustum
|
|
|
|
g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].SetCount( iVertCount + 2 ); //+2 for near and far z planes
|
|
|
|
Vector ptTransformedCamera = m_matrixThisToLinked * ptCurrentViewOrigin;
|
|
|
|
//generate planes defined by each line around the convex and the camera origin
|
|
for( i = 0; i != iVertCount; ++i )
|
|
{
|
|
Vector *p1, *p2;
|
|
p1 = &pInVerts[i];
|
|
p2 = &pInVerts[(i+1)%iVertCount];
|
|
|
|
Vector vLine1 = *p1 - ptCurrentViewOrigin;
|
|
Vector vLine2 = *p2 - ptCurrentViewOrigin;
|
|
Vector vNormal = vLine1.Cross( vLine2 );
|
|
vNormal.NormalizeInPlace();
|
|
|
|
vNormal = m_matrixThisToLinked.ApplyRotation( vNormal );
|
|
g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Element(i).Init( vNormal, vNormal.Dot( ptTransformedCamera ) );
|
|
}
|
|
|
|
//Near Z
|
|
g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Element(i).Init( m_pLinkedPortal->m_vForward, m_pLinkedPortal->m_InternallyMaintainedData.m_fPlaneDist );
|
|
|
|
//Far Z
|
|
++i;
|
|
{
|
|
Vector vNormal = m_matrixThisToLinked.ApplyRotation( pInputFrustum[iInputFrustumPlaneCount - 1].m_Normal );
|
|
Vector ptOnPlane = pInputFrustum[iInputFrustumPlaneCount - 1].m_Dist * pInputFrustum[iInputFrustumPlaneCount - 1].m_Normal;
|
|
g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Element(i).Init( vNormal, vNormal.Dot( m_matrixThisToLinked * ptOnPlane ) );
|
|
}
|
|
|
|
|
|
|
|
|
|
if( iVertCount > 4 )
|
|
{
|
|
float *fLineLengthSqr = (float *)stackalloc( sizeof( float ) * iVertCount );
|
|
VPlane *Planes = (VPlane *)stackalloc( sizeof( VPlane ) * iVertCount );
|
|
|
|
memcpy( Planes, g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Base(), sizeof( VPlane ) * iVertCount );
|
|
|
|
for( i = 0; i != (iVertCount - 1); ++i )
|
|
{
|
|
fLineLengthSqr[i] = (pInVerts[i + 1] - pInVerts[i]).LengthSqr();
|
|
}
|
|
fLineLengthSqr[i] = (pInVerts[0] - pInVerts[i]).LengthSqr(); //wrap around
|
|
|
|
|
|
while( iVertCount > 4 )
|
|
{
|
|
//we have too many verts to represent this accurately as a frustum,
|
|
//so, we're going to eliminate the smallest sides and bridge the surrounding sides until we're down to 4
|
|
|
|
float fMinSide = fLineLengthSqr[0];
|
|
int iMinSideFirstPoint = 0;
|
|
int iOldVertCount = iVertCount;
|
|
--iVertCount; //we're going to decrement this sometime in this block, it makes math easier to do it now
|
|
|
|
for( i = 1; i != iOldVertCount; ++i )
|
|
{
|
|
if( fLineLengthSqr[i] < fMinSide )
|
|
{
|
|
fMinSide = fLineLengthSqr[i];
|
|
iMinSideFirstPoint = i;
|
|
}
|
|
}
|
|
|
|
int i1, i2, i3, i4;
|
|
i1 = (iMinSideFirstPoint + iVertCount)%(iOldVertCount);
|
|
i2 = iMinSideFirstPoint;
|
|
i3 = (iMinSideFirstPoint + 1)%(iOldVertCount);
|
|
i4 = (iMinSideFirstPoint + 2)%(iOldVertCount);
|
|
|
|
Vector *p1, *p2, *p3, *p4;
|
|
p1 = &pInVerts[i1];
|
|
p2 = &pInVerts[i2];
|
|
p3 = &pInVerts[i3];
|
|
p4 = &pInVerts[i4];
|
|
|
|
|
|
//now we know the two points that we have to merge to one, project and make a merged point from the surrounding lines
|
|
if( fMinSide >= 0.1f ) //only worth doing the math if it's actually going to be accurate and make a difference
|
|
{
|
|
Vector vLine1 = *p2 - *p1;
|
|
Vector vLine2 = *p3 - *p4;
|
|
|
|
Vector vLine1Normal = vLine1.Cross( m_vForward );
|
|
vLine1Normal.NormalizeInPlace();
|
|
|
|
float fNormalDot = vLine1Normal.Dot( vLine2 );
|
|
|
|
AssertMsgOnce( fNormalDot != 0.0f, "Tell Dave Kircher if this pops up. It won't interfere with gameplay though" );
|
|
if( fNormalDot == 0.0f )
|
|
{
|
|
return false; //something went horribly wrong, bail and just suffer a slight framerate penalty for now
|
|
}
|
|
|
|
float fDist = vLine1Normal.Dot(*p1 - *p4);
|
|
*p2 = *p4 + (vLine2 * (fDist/fNormalDot));
|
|
}
|
|
|
|
fLineLengthSqr[i1] = (*p2 - *p1).LengthSqr();
|
|
fLineLengthSqr[i2] = (*p4 - *p2).LengthSqr(); //must do this BEFORE possibly shifting points p4+ left
|
|
|
|
if( i2 < i3 )
|
|
{
|
|
VPlane *v2 = &Planes[iMinSideFirstPoint];
|
|
memcpy( v2, v2 + 1, sizeof( VPlane ) * (iVertCount - iMinSideFirstPoint) );
|
|
}
|
|
|
|
if( i3 < i4 ) //not the last point in the array
|
|
{
|
|
int iElementShift = (iOldVertCount - i4);
|
|
|
|
//eliminate p3, we merged p2+p3 and already stored the result in p2
|
|
memcpy( p3, p3 + 1, sizeof( Vector ) * iElementShift );
|
|
|
|
float *l3 = &fLineLengthSqr[i3];
|
|
memcpy( l3, l3 + 1, sizeof( float ) * iElementShift );
|
|
}
|
|
}
|
|
|
|
for( i = 0; i != 4; ++i )
|
|
{
|
|
OutputFrustum[i] = Planes[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( i = 0; i != iVertCount; ++i )
|
|
{
|
|
OutputFrustum[i] = g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Element(i);
|
|
}
|
|
|
|
for( ; i != 4; ++i )
|
|
{
|
|
//we had less than 4 planes for the sides, just copy from the last valid plane
|
|
OutputFrustum[i] = OutputFrustum[iVertCount-1];
|
|
}
|
|
}
|
|
|
|
//copy near/far planes
|
|
int iComplexCount = g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Count();
|
|
OutputFrustum[FRUSTUM_NEARZ] = g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Element(iComplexCount-2);
|
|
OutputFrustum[FRUSTUM_FARZ] = g_pPortalRender->m_RecursiveViewComplexFrustums[iNextViewRecursionLevel].Element(iComplexCount-1);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
void CPortalRenderable_FlatBasic::RenderPortalViewToBackBuffer( CViewRender *pViewRender, const CViewSetup &cameraView )
|
|
{
|
|
VPROF( "CPortalRenderable_FlatBasic::RenderPortalViewToBackBuffer" );
|
|
|
|
if( m_fStaticAmount == 1.0f )
|
|
return; //not going to see anything anyways
|
|
|
|
if( m_pLinkedPortal == NULL ) //not linked to any portal, so we'll be all static anyways
|
|
return;
|
|
|
|
Frustum FrustumBackup;
|
|
memcpy( FrustumBackup, pViewRender->GetFrustum(), sizeof( Frustum ) );
|
|
|
|
Frustum seeThroughFrustum;
|
|
bool bUseSeeThroughFrustum;
|
|
|
|
bUseSeeThroughFrustum = CalcFrustumThroughPortal( cameraView.origin, seeThroughFrustum );
|
|
|
|
Vector vCameraForward;
|
|
AngleVectors( cameraView.angles, &vCameraForward, NULL, NULL );
|
|
|
|
// Setup fog state for the camera.
|
|
Vector ptPOVOrigin = m_matrixThisToLinked * cameraView.origin;
|
|
Vector vPOVForward = m_matrixThisToLinked.ApplyRotation( vCameraForward );
|
|
|
|
Vector ptRemotePortalPosition = m_pLinkedPortal->m_ptOrigin;
|
|
Vector vRemotePortalForward = m_pLinkedPortal->m_vForward;
|
|
|
|
CViewSetup portalView = cameraView;
|
|
|
|
if( portalView.zNear < 1.0f )
|
|
portalView.zNear = 1.0f;
|
|
|
|
QAngle qPOVAngles = TransformAnglesToWorldSpace( cameraView.angles, m_matrixThisToLinked.As3x4() );
|
|
|
|
portalView.width = cameraView.width;
|
|
portalView.height = cameraView.height;
|
|
portalView.x = cameraView.x;
|
|
portalView.y = cameraView.y;
|
|
portalView.origin = ptPOVOrigin;
|
|
portalView.angles = qPOVAngles;
|
|
portalView.fov = cameraView.fov;
|
|
portalView.m_bOrtho = false;
|
|
portalView.m_flAspectRatio = cameraView.m_flAspectRatio;
|
|
|
|
CopyToCurrentView( pViewRender, portalView );
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
{
|
|
float fCustomClipPlane[4];
|
|
fCustomClipPlane[0] = vRemotePortalForward.x;
|
|
fCustomClipPlane[1] = vRemotePortalForward.y;
|
|
fCustomClipPlane[2] = vRemotePortalForward.z;
|
|
fCustomClipPlane[3] = vRemotePortalForward.Dot( ptRemotePortalPosition - (vRemotePortalForward * 0.5f) ); //moving it back a smidge to eliminate visual artifacts for half-in objects
|
|
|
|
pRenderContext->PushCustomClipPlane( fCustomClipPlane ); //this is technically the same plane within recursive views, but pushing it anyway in-case something else has been added to the stack
|
|
}
|
|
|
|
|
|
{
|
|
ViewCustomVisibility_t customVisibility;
|
|
m_pLinkedPortal->AddToVisAsExitPortal( &customVisibility );
|
|
render->Push3DView( portalView, 0, NULL, pViewRender->GetFrustum() );
|
|
{
|
|
if( bUseSeeThroughFrustum)
|
|
memcpy( pViewRender->GetFrustum(), seeThroughFrustum, sizeof( Frustum ) );
|
|
|
|
render->OverrideViewFrustum( pViewRender->GetFrustum() );
|
|
SetViewRecursionLevel( g_pPortalRender->GetViewRecursionLevel() + 1 );
|
|
|
|
CPortalRenderable *pRenderingViewForPortalBackup = g_pPortalRender->GetCurrentViewEntryPortal();
|
|
CPortalRenderable *pRenderingViewExitPortalBackup = g_pPortalRender->GetCurrentViewExitPortal();
|
|
SetViewEntranceAndExitPortals( this, m_pLinkedPortal );
|
|
|
|
//DRAW!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
ViewDrawScene_PortalStencil( pViewRender, portalView, &customVisibility );
|
|
|
|
SetViewEntranceAndExitPortals( pRenderingViewForPortalBackup, pRenderingViewExitPortalBackup );
|
|
|
|
if( m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration && (g_pPortalRender->GetRemainingPortalViewDepth() == 1) )
|
|
{
|
|
//save the view matrix for usage with the depth doubler.
|
|
//It's important that we do this AFTER using the depth doubler this frame to compensate for the fact that the front buffer is 1 frame behind the current view matrix
|
|
//otherwise we get a lag effect when the player changes their viewing angles
|
|
pRenderContext->GetMatrix( MATERIAL_VIEW, &m_InternallyMaintainedData.m_DepthDoublerTextureView );
|
|
}
|
|
|
|
SetViewRecursionLevel( g_pPortalRender->GetViewRecursionLevel() - 1 );
|
|
}
|
|
render->PopView( pViewRender->GetFrustum() );
|
|
|
|
//restore old frustum
|
|
memcpy( pViewRender->GetFrustum(), FrustumBackup, sizeof( Frustum ) );
|
|
render->OverrideViewFrustum( FrustumBackup );
|
|
}
|
|
|
|
pRenderContext->PopCustomClipPlane();
|
|
|
|
//restore old vis data
|
|
CopyToCurrentView( pViewRender, cameraView );
|
|
}
|
|
|
|
|
|
void CPortalRenderable_FlatBasic::RenderPortalViewToTexture( CViewRender *pViewRender, const CViewSetup &cameraView )
|
|
{
|
|
if( m_fStaticAmount == 1.0f )
|
|
return; //not going to see anything anyways
|
|
|
|
if( m_pLinkedPortal == NULL ) //not linked to any portal, so we'll be all static anyways
|
|
return;
|
|
|
|
float fPixelVisibilty = g_pPortalRender->GetPixelVisilityForPortalSurface( this );
|
|
if( (fPixelVisibilty >= 0.0f) && (fPixelVisibilty <= PORTALRENDERABLE_FLATBASIC_MINPIXELVIS) )
|
|
return;
|
|
|
|
ITexture *pRenderTarget;
|
|
if( m_bIsPortal2 )
|
|
pRenderTarget = portalrendertargets->GetPortal2Texture();
|
|
else
|
|
pRenderTarget = portalrendertargets->GetPortal1Texture();
|
|
|
|
// Require that we have render textures for drawing
|
|
AssertMsg( pRenderTarget, "Portal render targets not initialized properly" );
|
|
|
|
// We're about to dereference this, so just bail if we can't
|
|
if ( !pRenderTarget )
|
|
return;
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
Vector vCameraForward;
|
|
AngleVectors( cameraView.angles, &vCameraForward, NULL, NULL );
|
|
|
|
Frustum seeThroughFrustum;
|
|
bool bUseSeeThroughFrustum = CalcFrustumThroughPortal( cameraView.origin, seeThroughFrustum );
|
|
|
|
// Setup fog state for the camera.
|
|
Vector ptPOVOrigin = m_matrixThisToLinked * cameraView.origin;
|
|
Vector vPOVForward = m_matrixThisToLinked.ApplyRotation( vCameraForward );
|
|
|
|
Vector vCameraToPortal = m_ptOrigin - cameraView.origin;
|
|
|
|
CViewSetup portalView = cameraView;
|
|
Frustum frustumBackup;
|
|
memcpy( frustumBackup, pViewRender->GetFrustum(), sizeof( Frustum ) );
|
|
|
|
QAngle qPOVAngles = TransformAnglesToWorldSpace( cameraView.angles, m_matrixThisToLinked.As3x4() );
|
|
|
|
portalView.width = pRenderTarget->GetActualWidth();
|
|
portalView.height = pRenderTarget->GetActualHeight();
|
|
portalView.x = 0;
|
|
portalView.y = 0;
|
|
portalView.origin = ptPOVOrigin;
|
|
portalView.angles = qPOVAngles;
|
|
portalView.fov = cameraView.fov;
|
|
portalView.m_bOrtho = false;
|
|
portalView.m_flAspectRatio = (float)cameraView.width / (float)cameraView.height; //use the screen aspect ratio, 0.0f doesn't work as advertised
|
|
|
|
//pRenderContext->Flush( false );
|
|
|
|
float fCustomClipPlane[4];
|
|
fCustomClipPlane[0] = m_pLinkedPortal->m_vForward.x;
|
|
fCustomClipPlane[1] = m_pLinkedPortal->m_vForward.y;
|
|
fCustomClipPlane[2] = m_pLinkedPortal->m_vForward.z;
|
|
fCustomClipPlane[3] = m_pLinkedPortal->m_vForward.Dot( m_pLinkedPortal->m_ptOrigin - (m_pLinkedPortal->m_vForward * 0.5f) ); //moving it back a smidge to eliminate visual artifacts for half-in objects
|
|
|
|
pRenderContext->PushCustomClipPlane( fCustomClipPlane );
|
|
|
|
{
|
|
render->Push3DView( portalView, VIEW_CLEAR_DEPTH, pRenderTarget, pViewRender->GetFrustum() );
|
|
|
|
{
|
|
ViewCustomVisibility_t customVisibility;
|
|
m_pLinkedPortal->AddToVisAsExitPortal( &customVisibility );
|
|
|
|
SetRemainingViewDepth( 0 );
|
|
SetViewRecursionLevel( 1 );
|
|
|
|
CPortalRenderable *pRenderingViewForPortalBackup = g_pPortalRender->GetCurrentViewEntryPortal();
|
|
CPortalRenderable *pRenderingViewExitPortalBackup = g_pPortalRender->GetCurrentViewExitPortal();
|
|
SetViewEntranceAndExitPortals( this, m_pLinkedPortal );
|
|
|
|
bool bDrew3dSkybox = false;
|
|
SkyboxVisibility_t nSkyboxVisible = SKYBOX_NOT_VISIBLE;
|
|
|
|
// if the 3d skybox world is drawn, then don't draw the normal skybox
|
|
int nClearFlags = 0;
|
|
Draw3dSkyboxworld_Portal( pViewRender, portalView, nClearFlags, bDrew3dSkybox, nSkyboxVisible, pRenderTarget );
|
|
|
|
if( bUseSeeThroughFrustum )
|
|
{
|
|
memcpy( pViewRender->GetFrustum(), seeThroughFrustum, sizeof( Frustum ) );
|
|
}
|
|
|
|
render->OverrideViewFrustum( pViewRender->GetFrustum() );
|
|
|
|
pRenderContext->EnableUserClipTransformOverride( false );
|
|
|
|
ViewDrawScene( pViewRender, bDrew3dSkybox, nSkyboxVisible, portalView, nClearFlags, (view_id_t)g_pPortalRender->GetCurrentViewId(), false, 0, &customVisibility );
|
|
|
|
SetViewEntranceAndExitPortals( pRenderingViewForPortalBackup, pRenderingViewExitPortalBackup );
|
|
|
|
SetRemainingViewDepth( 1 );
|
|
SetViewRecursionLevel( 0 );
|
|
|
|
memcpy( pViewRender->GetFrustum(), frustumBackup, sizeof( Frustum ) );
|
|
render->OverrideViewFrustum( pViewRender->GetFrustum() );
|
|
}
|
|
|
|
render->PopView( pViewRender->GetFrustum() );
|
|
}
|
|
|
|
pRenderContext->PopCustomClipPlane();
|
|
|
|
//pRenderContext->Flush( false );
|
|
|
|
CopyToCurrentView( pViewRender, cameraView );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// AddToVisAsExitPortal
|
|
// input - pViewRender: pointer to the CViewRender class used to render this scene.
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void CPortalRenderable_FlatBasic::AddToVisAsExitPortal( ViewCustomVisibility_t *pCustomVisibility )
|
|
{
|
|
if ( !pCustomVisibility )
|
|
return;
|
|
|
|
// Add four corners of the portal to the renderer as visibility origins
|
|
for ( int i = 0; i < 4; ++i )
|
|
{
|
|
if( enginetrace->GetLeafContainingPoint( m_InternallyMaintainedData.m_ptCorners[i] ) != -1 )
|
|
pCustomVisibility->AddVisOrigin( m_InternallyMaintainedData.m_ptCorners[i] );
|
|
}
|
|
|
|
// Specify which leaf to use for area portal culling
|
|
pCustomVisibility->ForceVisOverride( m_InternallyMaintainedData.m_VisData );
|
|
pCustomVisibility->ForceViewLeaf( m_InternallyMaintainedData.m_iViewLeaf );
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::DrawPreStencilMask( void )
|
|
{
|
|
if ( ( m_fOpenAmount > 0.0f ) && ( m_fOpenAmount < 1.0f ) )
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_Portal_Refract[ ( ( m_bIsPortal2 ) ? ( 1 ) : ( 0 ) ) ] );
|
|
}
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::DrawStencilMask( void )
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_Portal_Stencil_Hole );
|
|
DrawRenderFixMesh( g_pPortalRender->m_MaterialsAccess.m_WriteZ_Model );
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::DrawPostStencilFixes( void )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
//fast clipping may have hosed depth, reset it
|
|
pRenderContext->ClearBuffersObeyStencil( false, true );
|
|
|
|
//replace the fog we overwrote
|
|
RenderFogQuad();
|
|
|
|
//replace depth
|
|
DrawSimplePortalMesh( g_pPortalRender->m_MaterialsAccess.m_WriteZ_Model, 0.0f );
|
|
DrawRenderFixMesh( g_pPortalRender->m_MaterialsAccess.m_WriteZ_Model, 0.0f );
|
|
}
|
|
|
|
bool CPortalRenderable_FlatBasic::ShouldUpdateDepthDoublerTexture( const CViewSetup &viewSetup )
|
|
{
|
|
return ( (m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration) &&
|
|
(m_pLinkedPortal != NULL) &&
|
|
(m_fStaticAmount < 1.0f) );
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::HandlePortalPlaybackMessage( KeyValues *pKeyValues )
|
|
{
|
|
int nLinkedPortalId = pKeyValues->GetInt( "linkedPortalId" );
|
|
m_fOpenAmount = pKeyValues->GetFloat( "openAmount" );
|
|
m_fStaticAmount = pKeyValues->GetFloat( "staticAmount" );
|
|
m_fSecondaryStaticAmount = pKeyValues->GetFloat( "secondaryStaticAmount" );
|
|
m_bIsPortal2 = pKeyValues->GetInt( "isPortal2" ) != 0;
|
|
m_pLinkedPortal = nLinkedPortalId >= 0 ? (CPortalRenderable_FlatBasic *)FindRecordedPortal( nLinkedPortalId ) : NULL;
|
|
matrix3x4_t *pMat = (matrix3x4_t*)pKeyValues->GetPtr( "portalToWorld" );
|
|
|
|
MatrixGetColumn( *pMat, 3, m_ptOrigin );
|
|
MatrixGetColumn( *pMat, 0, m_vForward );
|
|
MatrixGetColumn( *pMat, 1, m_vRight );
|
|
MatrixGetColumn( *pMat, 2, m_vUp );
|
|
m_vRight *= -1.0f;
|
|
|
|
PortalMoved();
|
|
}
|
|
|
|
extern ConVar mat_wireframe;
|
|
static void DrawComplexPortalMesh_SubQuad( Vector &ptBottomLeft, Vector &vUp, Vector &vRight, float *fSubQuadRect, void *pBindEnt, const IMaterial *pMaterial, const VMatrix *pReplacementViewMatrixForTexCoords = NULL )
|
|
{
|
|
PortalMeshPoint_t Vertices[4];
|
|
|
|
Vertices[0].vWorldSpacePosition = ptBottomLeft + (vRight * fSubQuadRect[2]) + (vUp * fSubQuadRect[3]);
|
|
Vertices[0].texCoord.x = fSubQuadRect[2];
|
|
Vertices[0].texCoord.y = fSubQuadRect[3];
|
|
|
|
Vertices[1].vWorldSpacePosition = ptBottomLeft + (vRight * fSubQuadRect[2]) + (vUp * fSubQuadRect[1]);
|
|
Vertices[1].texCoord.x = fSubQuadRect[2];
|
|
Vertices[1].texCoord.y = fSubQuadRect[1];
|
|
|
|
Vertices[2].vWorldSpacePosition = ptBottomLeft + (vRight * fSubQuadRect[0]) + (vUp * fSubQuadRect[1]);
|
|
Vertices[2].texCoord.x = fSubQuadRect[0];
|
|
Vertices[2].texCoord.y = fSubQuadRect[1];
|
|
|
|
Vertices[3].vWorldSpacePosition = ptBottomLeft + (vRight * fSubQuadRect[0]) + (vUp * fSubQuadRect[3]);
|
|
Vertices[3].texCoord.x = fSubQuadRect[0];
|
|
Vertices[3].texCoord.y = fSubQuadRect[3];
|
|
|
|
Clip_And_Render_Convex_Polygon( Vertices, 4, pMaterial, pBindEnt );
|
|
}
|
|
|
|
#define PORTAL_PROJECTION_MESH_SUBDIVIDE_HEIGHTCHUNKS 8
|
|
#define PORTAL_PROJECTION_MESH_SUBDIVIDE_WIDTHCHUNKS 6
|
|
|
|
void CPortalRenderable_FlatBasic::DrawComplexPortalMesh( const IMaterial *pMaterialOverride, float fForwardOffsetModifier ) //generates and draws the portal mesh (Needed for compatibility with fixed function rendering)
|
|
{
|
|
PortalMeshPoint_t BaseVertices[4];
|
|
|
|
Vector ptBottomLeft = m_ptOrigin + (m_vForward * (fForwardOffsetModifier)) - (m_vRight * PORTAL_HALF_WIDTH) - (m_vUp * PORTAL_HALF_HEIGHT);
|
|
Vector vScaledUp = m_vUp * (2.0f * PORTAL_HALF_HEIGHT);
|
|
Vector vScaledRight = m_vRight * (2.0f * PORTAL_HALF_WIDTH);
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
VMatrix matView;
|
|
pRenderContext->GetMatrix( MATERIAL_VIEW, &matView );
|
|
|
|
const IMaterial *pMaterial;
|
|
if( pMaterialOverride )
|
|
{
|
|
pMaterial = pMaterialOverride;
|
|
}
|
|
else
|
|
{
|
|
pMaterial = m_Materials.m_PortalMaterials[(m_bIsPortal2)?1:0];
|
|
}
|
|
|
|
|
|
float fSubQuadRect[4] = { 0.0f, 0.0f, 1.0f, 1.0f };
|
|
|
|
float fHeightBegin = 0.0f;
|
|
for( int i = 0; i != PORTAL_PROJECTION_MESH_SUBDIVIDE_HEIGHTCHUNKS; ++i )
|
|
{
|
|
float fHeightEnd = fHeightBegin + (1.0f / ((float)PORTAL_PROJECTION_MESH_SUBDIVIDE_HEIGHTCHUNKS));
|
|
|
|
fSubQuadRect[1] = fHeightBegin;
|
|
fSubQuadRect[3] = fHeightEnd;
|
|
|
|
float fWidthBegin = 0.0f;
|
|
for( int j = 0; j != PORTAL_PROJECTION_MESH_SUBDIVIDE_WIDTHCHUNKS; ++j )
|
|
{
|
|
float fWidthEnd = fWidthBegin + (1.0f / ((float)PORTAL_PROJECTION_MESH_SUBDIVIDE_WIDTHCHUNKS));
|
|
|
|
fSubQuadRect[0] = fWidthBegin;
|
|
fSubQuadRect[2] = fWidthEnd;
|
|
|
|
DrawComplexPortalMesh_SubQuad( ptBottomLeft, vScaledUp, vScaledRight, fSubQuadRect, GetClientRenderable(), pMaterial );
|
|
|
|
fWidthBegin = fWidthEnd;
|
|
}
|
|
fHeightBegin = fHeightEnd;
|
|
}
|
|
|
|
//pRenderContext->Flush( false );
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::DrawDepthDoublerMesh( float fForwardOffsetModifier )
|
|
{
|
|
IMaterialVar *pDepthDoubleViewMatrixVar = s_FlatBasicPortalDrawingMaterials.m_Materials.m_PortalDepthDoubler->FindVar( "$alternateviewmatrix", NULL, false );
|
|
if ( pDepthDoubleViewMatrixVar )
|
|
pDepthDoubleViewMatrixVar->SetMatrixValue( m_InternallyMaintainedData.m_DepthDoublerTextureView );
|
|
DrawSimplePortalMesh( m_Materials.m_PortalDepthDoubler, fForwardOffsetModifier );
|
|
}
|
|
|
|
|
|
|
|
void CPortalRenderable_FlatBasic::DrawSimplePortalMesh( const IMaterial *pMaterialOverride, float fForwardOffsetModifier )
|
|
{
|
|
const IMaterial *pMaterial;
|
|
if( pMaterialOverride )
|
|
pMaterial = pMaterialOverride;
|
|
else
|
|
pMaterial = m_Materials.m_PortalMaterials[m_bIsPortal2?1:0];
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
pRenderContext->Bind( (IMaterial *)pMaterial, GetClientRenderable() );
|
|
|
|
// This can depend on the Bind command above, so keep this after!
|
|
UpdateFrontBufferTexturesForMaterial( (IMaterial *)pMaterial );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL ); //just in case
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
Vector ptCenter = m_ptOrigin + (m_vForward * fForwardOffsetModifier);
|
|
|
|
Vector verts[4];
|
|
verts[0] = ptCenter + (m_vRight * PORTAL_HALF_WIDTH) - (m_vUp * PORTAL_HALF_HEIGHT);
|
|
verts[1] = ptCenter + (m_vRight * PORTAL_HALF_WIDTH) + (m_vUp * PORTAL_HALF_HEIGHT);
|
|
verts[2] = ptCenter - (m_vRight * PORTAL_HALF_WIDTH) - (m_vUp * PORTAL_HALF_HEIGHT);
|
|
verts[3] = ptCenter - (m_vRight * PORTAL_HALF_WIDTH) + (m_vUp * PORTAL_HALF_HEIGHT);
|
|
|
|
float vTangent[4] = { -m_vRight.x, -m_vRight.y, -m_vRight.z, 1.0f };
|
|
|
|
CMeshBuilder meshBuilder;
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( false );
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, 2 );
|
|
|
|
meshBuilder.Position3fv( &verts[0].x );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
|
|
meshBuilder.TexCoord2f( 1, 0.0f, 1.0f );
|
|
meshBuilder.Normal3f( m_vForward.x, m_vForward.y, m_vForward.z );
|
|
meshBuilder.UserData( vTangent );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( &verts[1].x );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
|
|
meshBuilder.TexCoord2f( 1, 0.0f, 0.0f );
|
|
meshBuilder.Normal3f( m_vForward.x, m_vForward.y, m_vForward.z );
|
|
meshBuilder.UserData( vTangent );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( &verts[2].x );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
|
|
meshBuilder.TexCoord2f( 1, 1.0f, 1.0f );
|
|
meshBuilder.Normal3f( m_vForward.x, m_vForward.y, m_vForward.z );
|
|
meshBuilder.UserData( vTangent );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( &verts[3].x );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
|
|
meshBuilder.TexCoord2f( 1, 1.0f, 0.0f );
|
|
meshBuilder.Normal3f( m_vForward.x, m_vForward.y, m_vForward.z );
|
|
meshBuilder.UserData( vTangent );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
if( mat_wireframe.GetBool() )
|
|
{
|
|
pRenderContext->Bind( (IMaterial *)(const IMaterial *)g_pPortalRender->m_MaterialsAccess.m_Wireframe, (CPortalRenderable*)this );
|
|
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( false );
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, 2 );
|
|
|
|
meshBuilder.Position3fv( &verts[0].x );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
|
|
meshBuilder.TexCoord2f( 1, 0.0f, 1.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( &verts[1].x );
|
|
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
|
|
meshBuilder.TexCoord2f( 1, 0.0f, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( &verts[2].x );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
|
|
meshBuilder.TexCoord2f( 1, 1.0f, 1.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3fv( &verts[3].x );
|
|
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
|
|
meshBuilder.TexCoord2f( 1, 1.0f, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PopMatrix();
|
|
}
|
|
|
|
|
|
|
|
void CPortalRenderable_FlatBasic::DrawRenderFixMesh( const IMaterial *pMaterialOverride, float fFrontClipDistance )
|
|
{
|
|
const IMaterial *pMaterial;
|
|
if( pMaterialOverride )
|
|
pMaterial = pMaterialOverride;
|
|
else
|
|
pMaterial = m_Materials.m_PortalRenderFixMaterials[(m_bIsPortal2)?1:0];
|
|
|
|
if( g_pPortalRender->GetViewRecursionLevel() != 0 )
|
|
return; //a render fix should only ever be necessary in the primary view
|
|
|
|
Vector ptCameraOrigin = CurrentViewOrigin();
|
|
|
|
Vector vPortalCenterToCamera = ptCameraOrigin - m_ptOrigin;
|
|
if( (vPortalCenterToCamera.Dot( m_vForward ) < -1.0f) ) //camera coplanar (to 1.0 units) or in front of portal plane
|
|
return;
|
|
|
|
if( vPortalCenterToCamera.LengthSqr() < (PORTAL_HALF_HEIGHT * PORTAL_HALF_HEIGHT) ) //FIXME: Player closeness check might need reimplementation
|
|
{
|
|
//if the player is this close to the portal, immediately get rid of any static it has as well as draw the fix
|
|
m_fStaticAmount = 0.0f;
|
|
//m_fSecondaryStaticAmount = 0.0f;
|
|
|
|
float fOldDist = m_InternallyMaintainedData.m_BoundingPlanes[PORTALRENDERFIXMESH_OUTERBOUNDPLANES].m_Dist;
|
|
|
|
|
|
float fCameraDist = m_vForward.Dot(ptCameraOrigin - m_ptOrigin);
|
|
|
|
if( fFrontClipDistance > fCameraDist ) //never clip further out than the camera, we can see into the garbage space of the portal view's texture
|
|
fFrontClipDistance = fCameraDist;
|
|
|
|
m_InternallyMaintainedData.m_BoundingPlanes[PORTALRENDERFIXMESH_OUTERBOUNDPLANES].m_Dist -= fFrontClipDistance;
|
|
Internal_DrawRenderFixMesh( pMaterial );
|
|
m_InternallyMaintainedData.m_BoundingPlanes[PORTALRENDERFIXMESH_OUTERBOUNDPLANES].m_Dist = fOldDist;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::Internal_DrawRenderFixMesh( const IMaterial *pMaterial )
|
|
{
|
|
PortalMeshPoint_t WorkVertices[4];
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL ); //just in case
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
|
|
//view->GetViewSetup()->zNear;
|
|
Vector vForward, vUp, vRight, vOrigin;
|
|
vForward = CurrentViewForward();
|
|
vUp = CurrentViewUp();
|
|
vRight = CurrentViewRight();
|
|
|
|
vOrigin = CurrentViewOrigin() + vForward * (view->GetViewSetup()->zNear + 0.05f);
|
|
|
|
for( int i = 0; i != 4; ++i )
|
|
{
|
|
WorkVertices[i].texCoord.x = WorkVertices[i].texCoord.y = 0.0f;
|
|
}
|
|
|
|
WorkVertices[0].vWorldSpacePosition = vOrigin + (vRight * 40.0f) + (vUp * -40.0f);
|
|
WorkVertices[1].vWorldSpacePosition = vOrigin + (vRight * 40.0f) + (vUp * 40.0f);
|
|
WorkVertices[2].vWorldSpacePosition = vOrigin + (vRight * -40.0f) + (vUp * 40.0f);
|
|
WorkVertices[3].vWorldSpacePosition = vOrigin + (vRight * -40.0f) + (vUp * -40.0f);
|
|
|
|
ClipFixToBoundingAreaAndDraw( WorkVertices, pMaterial);
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PopMatrix();
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::ClipFixToBoundingAreaAndDraw( PortalMeshPoint_t *pVerts, const IMaterial *pMaterial )
|
|
{
|
|
PortalMeshPoint_t *pInVerts = (PortalMeshPoint_t *)stackalloc( 4 * (PORTALRENDERFIXMESH_OUTERBOUNDPLANES + 2) * 16 * sizeof( PortalMeshPoint_t ) ); //really only should need 4x points, but I'm paranoid
|
|
PortalMeshPoint_t *pOutVerts = (PortalMeshPoint_t *)stackalloc( 4 * (PORTALRENDERFIXMESH_OUTERBOUNDPLANES + 2) * 16 * sizeof( PortalMeshPoint_t ) );
|
|
PortalMeshPoint_t *pTempVerts;
|
|
|
|
memcpy( pInVerts, pVerts, sizeof( PortalMeshPoint_t ) * 4 );
|
|
int iVertCount = 4;
|
|
|
|
//clip by bounding area planes
|
|
{
|
|
for( int i = 0; i != (PORTALRENDERFIXMESH_OUTERBOUNDPLANES + 1); ++i )
|
|
{
|
|
if( iVertCount < 3 )
|
|
return; //nothing to draw
|
|
|
|
iVertCount = ClipPolyToPlane_LerpTexCoords( pInVerts, iVertCount, pOutVerts, m_InternallyMaintainedData.m_BoundingPlanes[i].m_Normal, m_InternallyMaintainedData.m_BoundingPlanes[i].m_Dist, 0.01f );
|
|
pTempVerts = pInVerts; pInVerts = pOutVerts; pOutVerts = pTempVerts; //swap vertex pointers
|
|
}
|
|
|
|
if( iVertCount < 3 )
|
|
return; //nothing to draw
|
|
}
|
|
|
|
|
|
//clip by the viewing frustum
|
|
{
|
|
VPlane *pFrustum = view->GetFrustum();
|
|
|
|
for( int i = 0; i != FRUSTUM_NUMPLANES; ++i )
|
|
{
|
|
if( iVertCount < 3 )
|
|
return; //nothing to draw
|
|
|
|
iVertCount = ClipPolyToPlane_LerpTexCoords( pInVerts, iVertCount, pOutVerts, pFrustum[i].m_Normal, pFrustum[i].m_Dist, 0.01f );
|
|
pTempVerts = pInVerts; pInVerts = pOutVerts; pOutVerts = pTempVerts; //swap vertex pointers
|
|
}
|
|
|
|
if( iVertCount < 3 )
|
|
return; //nothing to draw
|
|
}
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
//project the points so we can fudge the numbers a bit and move them to exactly 0.0f depth
|
|
{
|
|
VMatrix matProj, matView, matViewProj;
|
|
pRenderContext->GetMatrix( MATERIAL_PROJECTION, &matProj );
|
|
pRenderContext->GetMatrix( MATERIAL_VIEW, &matView );
|
|
MatrixMultiply( matProj, matView, matViewProj );
|
|
|
|
for( int i = 0; i != iVertCount; ++i )
|
|
{
|
|
float W, inverseW;
|
|
|
|
W = matViewProj.m[3][0] * pInVerts[i].vWorldSpacePosition.x;
|
|
W += matViewProj.m[3][1] * pInVerts[i].vWorldSpacePosition.y;
|
|
W += matViewProj.m[3][2] * pInVerts[i].vWorldSpacePosition.z;
|
|
W += matViewProj.m[3][3];
|
|
|
|
inverseW = 1.0f / W;
|
|
|
|
|
|
pInVerts[i].vWorldSpacePosition = matViewProj * pInVerts[i].vWorldSpacePosition;
|
|
pInVerts[i].vWorldSpacePosition *= inverseW;
|
|
pInVerts[i].vWorldSpacePosition.z = 0.00001f; //the primary reason we're projecting on the CPU to begin with
|
|
}
|
|
}
|
|
|
|
//render with identity transforms and clipping disabled
|
|
{
|
|
bool bClippingEnabled = pRenderContext->EnableClipping( false );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
RenderPortalMeshConvexPolygon( pInVerts, iVertCount, pMaterial, this );
|
|
if( mat_wireframe.GetBool() )
|
|
RenderPortalMeshConvexPolygon( pInVerts, iVertCount, materials->FindMaterial( "shadertest/wireframe", TEXTURE_GROUP_CLIENT_EFFECTS, false ), this );
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_VIEW );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
|
|
pRenderContext->PopMatrix();
|
|
|
|
pRenderContext->EnableClipping( bClippingEnabled );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// renders a quad that simulates fog as an overlay for something else (most notably the hole we create for stencil mode portals)
|
|
//-----------------------------------------------------------------------------
|
|
void CPortalRenderable_FlatBasic::RenderFogQuad( void )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
if( pRenderContext->GetFogMode() == MATERIAL_FOG_NONE )
|
|
return;
|
|
|
|
float fFogStart, fFogEnd;
|
|
pRenderContext->GetFogDistances( &fFogStart, &fFogEnd, NULL );
|
|
float vertexColor[4];
|
|
unsigned char fogColor[3];
|
|
pRenderContext->GetFogColor( fogColor );
|
|
|
|
/*float fColorScale = LinearToGammaFullRange( pRenderContext->GetToneMappingScaleLinear().x );
|
|
|
|
fogColor[0] *= fColorScale;
|
|
fogColor[1] *= fColorScale;
|
|
fogColor[2] *= fColorScale;*/
|
|
|
|
vertexColor[0] = fogColor[0] * (1.0f / 255.0f);
|
|
vertexColor[1] = fogColor[1] * (1.0f / 255.0f);
|
|
vertexColor[2] = fogColor[2] * (1.0f / 255.0f);
|
|
|
|
float ooFogRange = 1.0f;
|
|
if ( fFogEnd != fFogStart )
|
|
{
|
|
ooFogRange = 1.0f / (fFogEnd - fFogStart);
|
|
}
|
|
|
|
float FogEndOverFogRange = ooFogRange * fFogEnd;
|
|
|
|
VMatrix matView, matViewProj, matProj;
|
|
pRenderContext->GetMatrix( MATERIAL_VIEW, &matView );
|
|
pRenderContext->GetMatrix( MATERIAL_PROJECTION, &matProj );
|
|
MatrixMultiply( matProj, matView, matViewProj );
|
|
|
|
Vector vUp = m_vUp * (PORTAL_HALF_HEIGHT * 2.0f);
|
|
Vector vRight = m_vRight * (PORTAL_HALF_WIDTH * 2.0f);
|
|
|
|
Vector ptCorners[4];
|
|
ptCorners[0] = (m_ptOrigin + vUp) + vRight;
|
|
ptCorners[1] = (m_ptOrigin + vUp) - vRight;
|
|
ptCorners[2] = (m_ptOrigin - vUp) + vRight;
|
|
ptCorners[3] = (m_ptOrigin - vUp) - vRight;
|
|
|
|
|
|
pRenderContext->Bind( (IMaterial *)(const IMaterial *)g_pPortalRender->m_MaterialsAccess.m_TranslucentVertexColor );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, 2 );
|
|
|
|
for( int i = 0; i != 4; ++i )
|
|
{
|
|
float projZ;
|
|
projZ = matViewProj.m[2][0] * ptCorners[i].x;
|
|
projZ += matViewProj.m[2][1] * ptCorners[i].y;
|
|
projZ += matViewProj.m[2][2] * ptCorners[i].z;
|
|
projZ += matViewProj.m[2][3];
|
|
|
|
float fFogAmount = ((-projZ * ooFogRange) + FogEndOverFogRange); //projZ should be negative
|
|
|
|
//range fix
|
|
if( fFogAmount >= 1.0f )
|
|
fFogAmount = 1.0f;
|
|
|
|
if( fFogAmount <= 0.0f )
|
|
fFogAmount = 0.0f;
|
|
|
|
vertexColor[3] = 1.0f - fFogAmount; //alpha is inverse fog
|
|
|
|
meshBuilder.Position3fv( &ptCorners[i].x );
|
|
meshBuilder.Color4fv( vertexColor );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
}
|
|
|
|
void CPortalRenderable_FlatBasic::DrawPortal( void )
|
|
{
|
|
if( (view->GetDrawFlags() & DF_RENDER_REFLECTION) != 0 )
|
|
return;
|
|
|
|
if ( g_pPortalRender->ShouldUseStencilsToRenderPortals() )
|
|
{
|
|
//stencil-based rendering
|
|
if( g_pPortalRender->IsRenderingPortal() == false ) //main view
|
|
{
|
|
if( m_pLinkedPortal == NULL ) //didn't pass through pre-stencil mask
|
|
{
|
|
if ( ( m_fOpenAmount > 0.0f ) && ( m_fOpenAmount < 1.0f ) )
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_Portal_Refract[ ( ( m_bIsPortal2 ) ? ( 1 ) : ( 0 ) ) ] );
|
|
}
|
|
}
|
|
|
|
DrawSimplePortalMesh( m_Materials.m_PortalStaticOverlay[((m_bIsPortal2)?(1):(0))] );
|
|
DrawRenderFixMesh( g_pPortalRender->m_MaterialsAccess.m_WriteZ_Model );
|
|
}
|
|
else if( g_pPortalRender->GetCurrentViewExitPortal() != this )
|
|
{
|
|
if( m_pLinkedPortal == NULL ) //didn't pass through pre-stencil mask
|
|
{
|
|
if ( ( m_fOpenAmount > 0.0f ) && ( m_fOpenAmount < 1.0f ) )
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_Portal_Refract[ ( ( m_bIsPortal2 ) ? ( 1 ) : ( 0 ) ) ] );
|
|
}
|
|
}
|
|
|
|
if( (m_InternallyMaintainedData.m_bUsableDepthDoublerConfiguration)
|
|
&& (g_pPortalRender->GetRemainingPortalViewDepth() == 0)
|
|
&& (g_pPortalRender->GetViewRecursionLevel() > 1) )
|
|
{
|
|
DrawDepthDoublerMesh();
|
|
}
|
|
else
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_PortalStaticOverlay[((m_bIsPortal2)?(1):(0))] );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BeginPortalPixelVisibilityQuery();
|
|
|
|
//texture-based rendering
|
|
if( g_pPortalRender->IsRenderingPortal() == false )
|
|
{
|
|
if ( ( m_fOpenAmount > 0.0f ) && ( m_fOpenAmount < 1.0f ) )
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_Portal_Refract[ ( ( m_bIsPortal2 ) ? ( 1 ) : ( 0 ) ) ] );
|
|
}
|
|
|
|
DrawComplexPortalMesh();
|
|
DrawRenderFixMesh();
|
|
}
|
|
else if( g_pPortalRender->GetCurrentViewExitPortal() != this ) //don't render portals that our view is exiting from
|
|
{
|
|
if ( ( m_fOpenAmount > 0.0f ) && ( m_fOpenAmount < 1.0f ) )
|
|
{
|
|
DrawSimplePortalMesh( m_Materials.m_Portal_Refract[ ( ( m_bIsPortal2 ) ? ( 1 ) : ( 0 ) ) ] );
|
|
}
|
|
DrawSimplePortalMesh( m_Materials.m_PortalStaticOverlay[((m_bIsPortal2)?(1):(0))] ); //FIXME: find out why the projection mesh screws up at the second level of rendering in -nouserclip situations
|
|
}
|
|
|
|
EndPortalPixelVisibilityQuery();
|
|
}
|
|
}
|
|
|
|
bool CPortalRenderable_FlatBasic::DoesExitViewIntersectWaterPlane( float waterZ, int leafWaterDataID ) const
|
|
{
|
|
bool bAboveWater = false, bBelowWater = false;
|
|
for( int i = 0; i != 4; ++i )
|
|
{
|
|
bAboveWater |= (m_InternallyMaintainedData.m_ptCorners[i].z >= waterZ);
|
|
bBelowWater |= (m_InternallyMaintainedData.m_ptCorners[i].z <= waterZ);
|
|
}
|
|
|
|
return (bAboveWater && bBelowWater);
|
|
}
|
|
|
|
bool CPortalRenderable_FlatBasic::ShouldUpdatePortalView_BasedOnView( const CViewSetup ¤tView, CUtlVector<VPlane> ¤tComplexFrustum )
|
|
{
|
|
if( m_pLinkedPortal == NULL )
|
|
return false;
|
|
|
|
if( m_fStaticAmount == 1.0f )
|
|
return false;
|
|
|
|
Vector vCameraPos = currentView.origin;
|
|
|
|
if( (g_pPortalRender->GetViewRecursionLevel() == 0) &&
|
|
((m_ptOrigin - vCameraPos).LengthSqr() < (PORTAL_HALF_HEIGHT * PORTAL_HALF_HEIGHT)) ) //FIXME: Player closeness check might need reimplementation
|
|
{
|
|
return true; //fudgery time. The player might not be able to see the surface, but they can probably see the render fix
|
|
}
|
|
|
|
if( m_vForward.Dot( vCameraPos ) <= m_InternallyMaintainedData.m_fPlaneDist )
|
|
return false; //looking at portal backface
|
|
|
|
VPlane *currentFrustum = currentComplexFrustum.Base();
|
|
int iCurrentFrustmPlanes = currentComplexFrustum.Count();
|
|
|
|
//now slice up the portal quad and see if any is visible within the frustum
|
|
int allocSize = (6 + currentComplexFrustum.Count()); //possible to add 1 point per cut, 4 starting points, N plane cuts, 2 extra because I'm paranoid
|
|
Vector *pInVerts = (Vector *)stackalloc( sizeof( Vector ) * allocSize * 2 );
|
|
Vector *pOutVerts = pInVerts + allocSize;
|
|
Vector *pTempVerts;
|
|
|
|
//clip by first plane and put output into pInVerts
|
|
int iVertCount = ClipPolyToPlane( m_InternallyMaintainedData.m_ptCorners, 4, pInVerts, currentFrustum[0].m_Normal, currentFrustum[0].m_Dist, 0.01f );
|
|
|
|
//clip by other planes and flipflop in and out pointers
|
|
for( int i = 1; i != iCurrentFrustmPlanes; ++i )
|
|
{
|
|
if( iVertCount < 3 )
|
|
return false; //nothing left in the frustum
|
|
|
|
iVertCount = ClipPolyToPlane( pInVerts, iVertCount, pOutVerts, currentFrustum[i].m_Normal, currentFrustum[i].m_Dist, 0.01f );
|
|
pTempVerts = pInVerts; pInVerts = pOutVerts; pOutVerts = pTempVerts; //swap vertex pointers
|
|
}
|
|
|
|
if( iVertCount < 3 )
|
|
return false; //nothing left in the frustum
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPortalRenderable_FlatBasic::ShouldUpdatePortalView_BasedOnPixelVisibility( float fScreenFilledByStencilMaskLastFrame_Normalized )
|
|
{
|
|
return (fScreenFilledByStencilMaskLastFrame_Normalized < 0.0f) || // < 0 is an error value
|
|
(fScreenFilledByStencilMaskLastFrame_Normalized > PORTALRENDERABLE_FLATBASIC_MINPIXELVIS );
|
|
}
|
|
|
|
CPortalRenderable *CreatePortal_FlatBasic_Fn( void )
|
|
{
|
|
return new CPortalRenderable_FlatBasic;
|
|
}
|
|
|
|
static CPortalRenderableCreator CreatePortal_FlatBasic( "flatBasic", CreatePortal_FlatBasic_Fn );
|