diff options
Diffstat (limited to 'game/client/glow_overlay.cpp')
| -rw-r--r-- | game/client/glow_overlay.cpp | 577 |
1 files changed, 577 insertions, 0 deletions
diff --git a/game/client/glow_overlay.cpp b/game/client/glow_overlay.cpp new file mode 100644 index 0000000..7edecd8 --- /dev/null +++ b/game/client/glow_overlay.cpp @@ -0,0 +1,577 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// +#include "cbase.h" +#include "view.h" +#include "iviewrender.h" +#include "c_sun.h" +#include "particles_simple.h" +#include "clienteffectprecachesystem.h" +#include "c_pixel_visibility.h" +#include "glow_overlay.h" +#include "utllinkedlist.h" +#include "view_shared.h" +#include "tier0/vprof.h" +#include "materialsystem/imaterialvar.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectGlow ) +CLIENTEFFECT_MATERIAL( "sun/overlay" ) +CLIENTEFFECT_MATERIAL( "sprites/light_glow02_add_noz" ) +CLIENTEFFECT_REGISTER_END() + +class CGlowOverlaySystem : public CAutoGameSystem +{ +public: + CGlowOverlaySystem() : CAutoGameSystem( "CGlowOverlaySystem" ) + { + } + // Level init, shutdown + virtual void LevelInitPreEntity() {} + + virtual void LevelShutdownPostEntity() + { + m_GlowOverlays.PurgeAndDeleteElements(); + } + + unsigned short AddToOverlayList( CGlowOverlay *pGlow ) + { + return m_GlowOverlays.AddToTail( pGlow ); + } + void RemoveFromOverlayList( unsigned short handle ) + { + if( handle != m_GlowOverlays.InvalidIndex() ) + { + m_GlowOverlays.Remove( handle ); + } + } + CUtlLinkedList<CGlowOverlay*, unsigned short> m_GlowOverlays; +}; +CGlowOverlaySystem g_GlowOverlaySystem; + +ConVar cl_ShowSunVectors( "cl_ShowSunVectors", "0", 0 ); + +ConVar cl_sun_decay_rate( "cl_sun_decay_rate", "0.05", FCVAR_CHEAT ); + +// Dot product space the overlays are drawn in. +// Here it's setup to allow you to see it if you're looking within 40 degrees of the source. +float g_flOverlayRange = cos( DEG2RAD( 40 ) ); + +// ----------------------------------------------------------------------------- // +// ----------------------------------------------------------------------------- // + +void Do2DRotation( Vector vIn, Vector &vOut, float flDegrees, int i1, int i2, int i3 ) +{ + float c, s; + SinCos( DEG2RAD( flDegrees ), &s, &c ); + + vOut[i1] = vIn[i1]*c - vIn[i2]*s; + vOut[i2] = vIn[i1]*s + vIn[i2]*c; + vOut[i3] = vIn[i3]; +} + + +// ----------------------------------------------------------------------------- // +// ----------------------------------------------------------------------------- // + +CGlowOverlay::CGlowOverlay() +{ + m_ListIndex = 0xFFFF; + m_nSprites = 0; + m_flGlowObstructionScale = 0.0f; + m_bDirectional = false; + m_bInSky = false; + m_skyObstructionScale = 1.0f; + m_bActivated = false; + + m_flProxyRadius = 2.0f; + + m_queryHandle = 0; + + m_flHDRColorScale = 1.0f; + + //Init our sprites + for ( int i = 0; i < MAX_SUN_LAYERS; i++ ) + { + m_Sprites[i].m_vColor.Init(); + m_Sprites[i].m_flHorzSize = 1.0f; + m_Sprites[i].m_flVertSize = 1.0f; + m_Sprites[i].m_pMaterial = NULL; + } + +#ifdef PORTAL + for( int i = 0; i != MAX_PORTAL_RECURSIVE_VIEWS; ++i ) + { + m_skyObstructionScaleBackups[i] = 1.0f; + } +#endif +} + + +CGlowOverlay::~CGlowOverlay() +{ + g_GlowOverlaySystem.RemoveFromOverlayList( m_ListIndex ); +} + + +bool CGlowOverlay::Update() +{ + return true; +} + +ConVar building_cubemaps( "building_cubemaps", "0" ); + +float CGlowOverlay::CalcGlowAspect() +{ + if ( m_nSprites ) + { + if ( m_Sprites[0].m_flHorzSize != 0 && m_Sprites[0].m_flVertSize != 0 ) + return m_Sprites[0].m_flHorzSize / m_Sprites[0].m_flVertSize; + } + return 1.0f; +} + +void CGlowOverlay::UpdateSkyGlowObstruction( float zFar, bool bCacheFullSceneState ) +{ + Assert( m_bInSky ); + + // If we already cached the sky obstruction and are still using that, early-out + if ( bCacheFullSceneState && m_bCacheSkyObstruction ) + return; + + // Turning on sky obstruction caching mode + if ( bCacheFullSceneState && !m_bCacheSkyObstruction ) + { + m_bCacheSkyObstruction = true; + } + + // Turning off sky obstruction caching mode + if ( !bCacheFullSceneState && m_bCacheSkyObstruction ) + { + m_bCacheSkyObstruction = false; + } + + if ( PixelVisibility_IsAvailable() ) + { + // Trace a ray at the object. + Vector pos = CurrentViewOrigin() + m_vDirection * zFar * 0.999f; + + // UNDONE: Can probably do only the pixelvis query in this case if you can figure out where + // to put it - or save the position of this trace + pixelvis_queryparams_t params; + params.Init( pos, m_flProxyRadius ); + params.bSizeInScreenspace = true; + m_skyObstructionScale = PixelVisibility_FractionVisible( params, &m_queryHandle ); + return; + } + // Trace a ray at the object. + trace_t trace; + UTIL_TraceLine( CurrentViewOrigin(), CurrentViewOrigin() + (m_vDirection*MAX_TRACE_LENGTH), + CONTENTS_SOLID, NULL, COLLISION_GROUP_NONE, &trace ); + + // back the trace with a pixel query to occlude with models + if ( trace.surface.flags & SURF_SKY ) + { + m_skyObstructionScale = 1.0f; + } + else + { + m_skyObstructionScale = 0.0f; + } +} + + +void CGlowOverlay::UpdateGlowObstruction( const Vector &vToGlow, bool bCacheFullSceneState ) +{ + // If we already cached the glow obstruction and are still using that, early-out + if ( bCacheFullSceneState && m_bCacheGlowObstruction ) + return; + + if ( bCacheFullSceneState && !m_bCacheGlowObstruction ) // If turning on sky obstruction caching mode + { + m_bCacheGlowObstruction = true; + } + + if ( !bCacheFullSceneState && m_bCacheGlowObstruction ) + { + m_bCacheGlowObstruction = false; + } + + if ( PixelVisibility_IsAvailable() ) + { + if ( m_bInSky ) + { + const CViewSetup *pViewSetup = view->GetViewSetup(); + Vector pos = CurrentViewOrigin() + m_vDirection * (pViewSetup->zFar * 0.999f); + pixelvis_queryparams_t params; + params.Init( pos, m_flProxyRadius, CalcGlowAspect() ); + params.bSizeInScreenspace = true; + // use a pixel query to occlude with models + m_flGlowObstructionScale = PixelVisibility_FractionVisible( params, &m_queryHandle ) * m_skyObstructionScale; + } + else + { + // If it's not in the sky, then we need a valid position or else we don't + // know what's in front of it. + Assert( !m_bDirectional ); + + pixelvis_queryparams_t params; + params.Init( m_vPos, m_flProxyRadius, CalcGlowAspect() ); + + m_flGlowObstructionScale = PixelVisibility_FractionVisible( params, &m_queryHandle ); + } + return; + } + + bool bFade = false; + if ( m_bInSky ) + { + // Trace a ray at the object. + trace_t trace; + UTIL_TraceLine( CurrentViewOrigin(), CurrentViewOrigin() + (vToGlow*MAX_TRACE_LENGTH), + CONTENTS_SOLID, NULL, COLLISION_GROUP_NONE, &trace ); + + bFade = (trace.fraction < 1 && !(trace.surface.flags & SURF_SKY)); + } + else + { + // If it's not in the sky, then we need a valid position or else we don't + // know what's in front of it. + Assert( !m_bDirectional ); + + pixelvis_queryparams_t params; + params.Init( m_vPos, m_flProxyRadius ); + + bFade = PixelVisibility_FractionVisible( params, &m_queryHandle ) < 1.0f ? true : false; + + } + + if ( bFade ) + { + if ( building_cubemaps.GetBool() ) + { + m_flGlowObstructionScale = 0.0f; + } + else + { + m_flGlowObstructionScale -= gpGlobals->frametime / cl_sun_decay_rate.GetFloat(); + m_flGlowObstructionScale = MAX( m_flGlowObstructionScale, 0.0f ); + } + } + else + { + if ( building_cubemaps.GetBool() ) + { + m_flGlowObstructionScale = 1.0f; + } + else + { + m_flGlowObstructionScale += gpGlobals->frametime / cl_sun_decay_rate.GetFloat(); + m_flGlowObstructionScale = MIN( m_flGlowObstructionScale, 1.0f ); + } + } +} + +void CGlowOverlay::CalcSpriteColorAndSize( + float flDot, + CGlowSprite *pSprite, + float *flHorzSize, + float *flVertSize, + Vector *vColor ) +{ + // The overlay is largest and completely translucent at g_flOverlayRange. + // When the dot product is 1, then it's smaller and more opaque. + const float flSizeAtOverlayRangeMul = 150; + const float flSizeAtOneMul = 70; + + const float flOpacityAtOverlayRange = 0; + const float flOpacityAtOne = 1; + + // Figure out how big and how opaque it will be. + *flHorzSize = RemapValClamped( + flDot, + g_flOverlayRange, + 1, + flSizeAtOverlayRangeMul * pSprite->m_flHorzSize, + flSizeAtOneMul * pSprite->m_flHorzSize ); + + *flVertSize = RemapValClamped( + flDot, + g_flOverlayRange, + 1, + flSizeAtOverlayRangeMul * pSprite->m_flVertSize, + flSizeAtOneMul * pSprite->m_flVertSize ); + + float flOpacity = RemapValClamped( + flDot, + g_flOverlayRange, + 1, + flOpacityAtOverlayRange, + flOpacityAtOne ); + + flOpacity = flOpacity * m_flGlowObstructionScale; + *vColor = pSprite->m_vColor * flOpacity; +} + + +void CGlowOverlay::CalcBasis( + const Vector &vToGlow, + float flHorzSize, + float flVertSize, + Vector &vBasePt, + Vector &vUp, + Vector &vRight ) +{ + const float flOverlayDist = 100; + vBasePt = CurrentViewOrigin() + vToGlow * flOverlayDist; + + vUp.Init( 0, 0, 1 ); + + vRight = vToGlow.Cross( vUp ); + VectorNormalize( vRight ); + + vUp = vRight.Cross( vToGlow ); + VectorNormalize( vUp ); + + vRight *= flHorzSize; + vUp *= flVertSize; +} + + +void CGlowOverlay::Draw( bool bCacheFullSceneState ) +{ + extern ConVar r_drawsprites; + if( !r_drawsprites.GetBool() ) + return; + + // Get the vector to the sun. + Vector vToGlow; + + if( m_bDirectional ) + vToGlow = m_vDirection; + else + vToGlow = m_vPos - CurrentViewOrigin(); + + VectorNormalize( vToGlow ); + + float flDot = vToGlow.Dot( CurrentViewForward() ); + + UpdateGlowObstruction( vToGlow, bCacheFullSceneState ); + if( m_flGlowObstructionScale == 0 ) + return; + + bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawsprites.GetInt() == 2); + + CMatRenderContextPtr pRenderContext( materials ); + + for( int iSprite=0; iSprite < m_nSprites; iSprite++ ) + { + CGlowSprite *pSprite = &m_Sprites[iSprite]; + + // Figure out the color and size to draw it. + float flHorzSize, flVertSize; + Vector vColor; + CalcSpriteColorAndSize( flDot, pSprite, &flHorzSize, &flVertSize, &vColor ); + + // If we're alpha'd out, then don't bother + if ( vColor.LengthSqr() < 0.00001f ) + continue; + + // Setup the basis to draw the sprite. + Vector vBasePt, vUp, vRight; + CalcBasis( vToGlow, flHorzSize, flVertSize, vBasePt, vUp, vRight ); + + //Get our diagonal radius + float radius = (vRight+vUp).Length(); + if ( R_CullSphere( view->GetFrustum(), 5, &vBasePt, radius ) ) + continue; + + // Get our material (deferred default load) + if ( m_Sprites[iSprite].m_pMaterial == NULL ) + { + m_Sprites[iSprite].m_pMaterial = materials->FindMaterial( "sprites/light_glow02_add_noz", TEXTURE_GROUP_CLIENT_EFFECTS ); + } + + Assert( m_Sprites[iSprite].m_pMaterial ); + static unsigned int nHDRColorScaleCache = 0; + IMaterialVar *pHDRColorScaleVar = m_Sprites[iSprite].m_pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache ); + if( pHDRColorScaleVar ) + { + pHDRColorScaleVar->SetFloatValue( m_flHDRColorScale ); + } + + // Draw the sprite. + IMesh *pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, m_Sprites[iSprite].m_pMaterial ); + + CMeshBuilder builder; + builder.Begin( pMesh, MATERIAL_QUADS, 1 ); + + Vector vPt; + + vPt = vBasePt - vRight + vUp; + builder.Position3fv( vPt.Base() ); + builder.Color4f( VectorExpand(vColor), 1 ); + builder.TexCoord2f( 0, 0, 1 ); + builder.AdvanceVertex(); + + vPt = vBasePt + vRight + vUp; + builder.Position3fv( vPt.Base() ); + builder.Color4f( VectorExpand(vColor), 1 ); + builder.TexCoord2f( 0, 1, 1 ); + builder.AdvanceVertex(); + + vPt = vBasePt + vRight - vUp; + builder.Position3fv( vPt.Base() ); + builder.Color4f( VectorExpand(vColor), 1 ); + builder.TexCoord2f( 0, 1, 0 ); + builder.AdvanceVertex(); + + vPt = vBasePt - vRight - vUp; + builder.Position3fv( vPt.Base() ); + builder.Color4f( VectorExpand(vColor), 1 ); + builder.TexCoord2f( 0, 0, 0 ); + builder.AdvanceVertex(); + + builder.End( false, true ); + + if( bWireframe ) + { + IMaterial *pWireframeMaterial = materials->FindMaterial( "debug/debugwireframevertexcolor", TEXTURE_GROUP_OTHER ); + pRenderContext->Bind( pWireframeMaterial ); + + // Draw the sprite. + pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, pWireframeMaterial ); + + CMeshBuilder builderWireFrame; + builderWireFrame.Begin( pMesh, MATERIAL_QUADS, 1 ); + + vPt = vBasePt - vRight + vUp; + builderWireFrame.Position3fv( vPt.Base() ); + builderWireFrame.Color3f( 1.0f, 0.0f, 0.0f ); + builderWireFrame.AdvanceVertex(); + + vPt = vBasePt + vRight + vUp; + builderWireFrame.Position3fv( vPt.Base() ); + builderWireFrame.Color3f( 1.0f, 0.0f, 0.0f ); + builderWireFrame.AdvanceVertex(); + + vPt = vBasePt + vRight - vUp; + builderWireFrame.Position3fv( vPt.Base() ); + builderWireFrame.Color3f( 1.0f, 0.0f, 0.0f ); + builderWireFrame.AdvanceVertex(); + + vPt = vBasePt - vRight - vUp; + builderWireFrame.Position3fv( vPt.Base() ); + builderWireFrame.Color3f( 1.0f, 0.0f, 0.0f ); + builderWireFrame.AdvanceVertex(); + + builderWireFrame.End( false, true ); + } + } +} + + +void CGlowOverlay::Activate() +{ + m_bActivated = true; + if( m_ListIndex == 0xFFFF ) + { + m_ListIndex = g_GlowOverlaySystem.AddToOverlayList( this ); + } +} + + +void CGlowOverlay::Deactivate() +{ + m_bActivated = false; +} + + +void CGlowOverlay::DrawOverlays( bool bCacheFullSceneState ) +{ + VPROF("CGlowOverlay::DrawOverlays()"); + + CMatRenderContextPtr pRenderContext( materials ); + + bool bClippingEnabled = pRenderContext->EnableClipping( true ); + + unsigned short iNext; + for( unsigned short i=g_GlowOverlaySystem.m_GlowOverlays.Head(); i != g_GlowOverlaySystem.m_GlowOverlays.InvalidIndex(); i = iNext ) + { + iNext = g_GlowOverlaySystem.m_GlowOverlays.Next( i ); + CGlowOverlay *pOverlay = g_GlowOverlaySystem.m_GlowOverlays[i]; + + if( !pOverlay->m_bActivated ) + continue; + + if( pOverlay->Update() ) + { + pRenderContext->EnableClipping( ((pOverlay->m_bInSky) ? (false):(bClippingEnabled)) ); //disable clipping in skybox, restore clipping to pre-existing state when not in skybox (it may be off as well) + pOverlay->Draw( bCacheFullSceneState ); + } + else + { + delete pOverlay; + } + } + + pRenderContext->EnableClipping( bClippingEnabled ); //restore clipping to original state +} + +void CGlowOverlay::UpdateSkyOverlays( float zFar, bool bCacheFullSceneState ) +{ + unsigned short iNext; + for( unsigned short i=g_GlowOverlaySystem.m_GlowOverlays.Head(); i != g_GlowOverlaySystem.m_GlowOverlays.InvalidIndex(); i = iNext ) + { + iNext = g_GlowOverlaySystem.m_GlowOverlays.Next( i ); + CGlowOverlay *pOverlay = g_GlowOverlaySystem.m_GlowOverlays[i]; + + if( !pOverlay->m_bActivated || !pOverlay->m_bDirectional || !pOverlay->m_bInSky ) + continue; + + pOverlay->UpdateSkyGlowObstruction( zFar, bCacheFullSceneState ); + } +} + + + + +#ifdef PORTAL + +void CGlowOverlay::BackupSkyOverlayData( int iBackupToSlot ) +{ + unsigned short iNext; + for( unsigned short i=g_GlowOverlaySystem.m_GlowOverlays.Head(); i != g_GlowOverlaySystem.m_GlowOverlays.InvalidIndex(); i = iNext ) + { + iNext = g_GlowOverlaySystem.m_GlowOverlays.Next( i ); + CGlowOverlay *pOverlay = g_GlowOverlaySystem.m_GlowOverlays[i]; + + if( !pOverlay->m_bActivated || !pOverlay->m_bDirectional || !pOverlay->m_bInSky ) + continue; + + pOverlay->m_skyObstructionScaleBackups[iBackupToSlot] = pOverlay->m_skyObstructionScale; + } +} + +void CGlowOverlay::RestoreSkyOverlayData( int iRestoreFromSlot ) +{ + unsigned short iNext; + for( unsigned short i=g_GlowOverlaySystem.m_GlowOverlays.Head(); i != g_GlowOverlaySystem.m_GlowOverlays.InvalidIndex(); i = iNext ) + { + iNext = g_GlowOverlaySystem.m_GlowOverlays.Next( i ); + CGlowOverlay *pOverlay = g_GlowOverlaySystem.m_GlowOverlays[i]; + + if( !pOverlay->m_bActivated || !pOverlay->m_bDirectional || !pOverlay->m_bInSky ) + continue; + + pOverlay->m_skyObstructionScale = pOverlay->m_skyObstructionScaleBackups[iRestoreFromSlot]; + } +} + +#endif //#ifdef PORTAL + |