//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //=============================================================================// #include "cbase.h" #include "c_tracer.h" #include "view.h" #include "initializer.h" #include "particles_simple.h" #include "env_wind_shared.h" #include "engine/IEngineTrace.h" #include "engine/ivmodelinfo.h" #include "precipitation_shared.h" #include "fx_water.h" #include "c_world.h" #include "iviewrender.h" #include "engine/ivdebugoverlay.h" #include "clienteffectprecachesystem.h" #include "collisionutils.h" #include "tier0/vprof.h" #include "viewrender.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" ConVar cl_winddir ( "cl_winddir", "0", FCVAR_CHEAT, "Weather effects wind direction angle" ); ConVar cl_windspeed ( "cl_windspeed", "0", FCVAR_CHEAT, "Weather effects wind speed scalar" ); Vector g_vSplashColor( 0.5, 0.5, 0.5 ); float g_flSplashScale = 0.15; float g_flSplashLifetime = 0.5f; float g_flSplashAlpha = 0.3f; ConVar r_RainSplashPercentage( "r_RainSplashPercentage", "20", FCVAR_CHEAT ); // N% chance of a rain particle making a splash. float GUST_INTERVAL_MIN = 1; float GUST_INTERVAL_MAX = 2; float GUST_LIFETIME_MIN = 1; float GUST_LIFETIME_MAX = 3; float MIN_SCREENSPACE_RAIN_WIDTH = 1; #ifndef _XBOX ConVar r_RainHack( "r_RainHack", "0", FCVAR_CHEAT ); ConVar r_RainRadius( "r_RainRadius", "1500", FCVAR_CHEAT ); ConVar r_RainSideVel( "r_RainSideVel", "130", FCVAR_CHEAT, "How much sideways velocity rain gets." ); ConVar r_RainSimulate( "r_RainSimulate", "1", FCVAR_CHEAT, "Enable/disable rain simulation." ); ConVar r_DrawRain( "r_DrawRain", "1", FCVAR_CHEAT, "Enable/disable rain rendering." ); ConVar r_RainProfile( "r_RainProfile", "0", FCVAR_CHEAT, "Enable/disable rain profiling." ); //Precahce the effects CLIENTEFFECT_REGISTER_BEGIN( PrecachePrecipitation ) CLIENTEFFECT_MATERIAL( "particle/rain" ) CLIENTEFFECT_MATERIAL( "particle/snow" ) CLIENTEFFECT_REGISTER_END() //----------------------------------------------------------------------------- // Precipitation particle type //----------------------------------------------------------------------------- class CPrecipitationParticle { public: Vector m_Pos; Vector m_Velocity; float m_SpawnTime; // Note: Tweak with this to change lifetime float m_Mass; float m_Ramp; float m_flCurLifetime; float m_flMaxLifetime; }; class CClient_Precipitation; static CUtlVector g_Precipitations; //=========== // Snow fall //=========== class CSnowFallManager; static CSnowFallManager *s_pSnowFallMgr = NULL; bool SnowFallManagerCreate( CClient_Precipitation *pSnowEntity ); void SnowFallManagerDestroy( void ); class AshDebrisEffect : public CSimpleEmitter { public: AshDebrisEffect( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {} static AshDebrisEffect* Create( const char *pDebugName ); virtual float UpdateAlpha( const SimpleParticle *pParticle ); virtual float UpdateRoll( SimpleParticle *pParticle, float timeDelta ); private: AshDebrisEffect( const AshDebrisEffect & ); }; //----------------------------------------------------------------------------- // Precipitation base entity //----------------------------------------------------------------------------- class CClient_Precipitation : public C_BaseEntity { class CPrecipitationEffect; friend class CClient_Precipitation::CPrecipitationEffect; public: DECLARE_CLASS( CClient_Precipitation, C_BaseEntity ); DECLARE_CLIENTCLASS(); CClient_Precipitation(); virtual ~CClient_Precipitation(); // Inherited from C_BaseEntity virtual void Precache( ); void Render(); private: // Creates a single particle CPrecipitationParticle* CreateParticle(); virtual void OnDataChanged( DataUpdateType_t updateType ); virtual void ClientThink(); void Simulate( float dt ); // Renders the particle void RenderParticle( CPrecipitationParticle* pParticle, CMeshBuilder &mb ); void CreateWaterSplashes(); // Emits the actual particles void EmitParticles( float fTimeDelta ); // Computes where we're gonna emit bool ComputeEmissionArea( Vector& origin, Vector2D& size ); // Gets the tracer width and speed float GetWidth() const; float GetLength() const; float GetSpeed() const; // Gets the remaining lifetime of the particle float GetRemainingLifetime( CPrecipitationParticle* pParticle ) const; // Computes the wind vector static void ComputeWindVector( ); // simulation methods bool SimulateRain( CPrecipitationParticle* pParticle, float dt ); bool SimulateSnow( CPrecipitationParticle* pParticle, float dt ); void CreateAshParticle( void ); void CreateRainOrSnowParticle( Vector vSpawnPosition, Vector vVelocity ); // Information helpful in creating and rendering particles IMaterial *m_MatHandle; // material used float m_Color[4]; // precip color float m_Lifetime; // Precip lifetime float m_InitialRamp; // Initial ramp value float m_Speed; // Precip speed float m_Width; // Tracer width float m_Remainder; // particles we should render next time PrecipitationType_t m_nPrecipType; // Precip type float m_flHalfScreenWidth; // Precalculated each frame. float m_flDensity; // Some state used in rendering and simulation // Used to modify the rain density and wind from the console static ConVar s_raindensity; static ConVar s_rainwidth; static ConVar s_rainlength; static ConVar s_rainspeed; static Vector s_WindVector; // Stores the wind speed vector CUtlLinkedList m_Particles; CUtlVector m_Splashes; CSmartPtr m_pAshEmitter; TimedEvent m_tAshParticleTimer; TimedEvent m_tAshParticleTraceTimer; bool m_bActiveAshEmitter; Vector m_vAshSpawnOrigin; int m_iAshCount; private: CClient_Precipitation( const CClient_Precipitation & ); // not defined, not accessible }; // Just receive the normal data table stuff IMPLEMENT_CLIENTCLASS_DT(CClient_Precipitation, DT_Precipitation, CPrecipitation) RecvPropInt( RECVINFO( m_nPrecipType ) ) END_RECV_TABLE() static ConVar r_SnowEnable( "r_SnowEnable", "1", FCVAR_CHEAT, "Snow Enable" ); static ConVar r_SnowParticles( "r_SnowParticles", "500", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowInsideRadius( "r_SnowInsideRadius", "256", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowOutsideRadius( "r_SnowOutsideRadius", "1024", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowSpeedScale( "r_SnowSpeedScale", "1", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowPosScale( "r_SnowPosScale", "1", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowFallSpeed( "r_SnowFallSpeed", "1.5", FCVAR_CHEAT, "Snow fall speed scale." ); static ConVar r_SnowWindScale( "r_SnowWindScale", "0.0035", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowDebugBox( "r_SnowDebugBox", "0", FCVAR_CHEAT, "Snow Debug Boxes." ); static ConVar r_SnowZoomOffset( "r_SnowZoomOffset", "384.0f", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowZoomRadius( "r_SnowZoomRadius", "512.0f", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowStartAlpha( "r_SnowStartAlpha", "25", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowEndAlpha( "r_SnowEndAlpha", "255", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowColorRed( "r_SnowColorRed", "150", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowColorGreen( "r_SnowColorGreen", "175", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowColorBlue( "r_SnowColorBlue", "200", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowStartSize( "r_SnowStartSize", "1", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowEndSize( "r_SnowEndSize", "0", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowRayLength( "r_SnowRayLength", "8192.0f", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowRayRadius( "r_SnowRayRadius", "256", FCVAR_CHEAT, "Snow." ); static ConVar r_SnowRayEnable( "r_SnowRayEnable", "1", FCVAR_CHEAT, "Snow." ); void DrawPrecipitation() { for ( int i=0; i < g_Precipitations.Count(); i++ ) { g_Precipitations[i]->Render(); } } //----------------------------------------------------------------------------- // determines if a weather particle has hit something other than air //----------------------------------------------------------------------------- static bool IsInAir( const Vector& position ) { int contents = enginetrace->GetPointContents( position ); return (contents & CONTENTS_SOLID) == 0; } //----------------------------------------------------------------------------- // Globals //----------------------------------------------------------------------------- ConVar CClient_Precipitation::s_raindensity( "r_raindensity","0.001", FCVAR_CHEAT); ConVar CClient_Precipitation::s_rainwidth( "r_rainwidth", "0.5", FCVAR_CHEAT ); ConVar CClient_Precipitation::s_rainlength( "r_rainlength", "0.1f", FCVAR_CHEAT ); ConVar CClient_Precipitation::s_rainspeed( "r_rainspeed", "600.0f", FCVAR_CHEAT ); ConVar r_rainalpha( "r_rainalpha", "0.4", FCVAR_CHEAT ); ConVar r_rainalphapow( "r_rainalphapow", "0.8", FCVAR_CHEAT ); Vector CClient_Precipitation::s_WindVector; // Stores the wind speed vector void CClient_Precipitation::OnDataChanged( DataUpdateType_t updateType ) { // Simulate every frame. if ( updateType == DATA_UPDATE_CREATED ) { SetNextClientThink( CLIENT_THINK_ALWAYS ); if ( m_nPrecipType == PRECIPITATION_TYPE_SNOWFALL ) { SnowFallManagerCreate( this ); } } m_flDensity = RemapVal( m_clrRender->a, 0, 255, 0, 0.001 ); BaseClass::OnDataChanged( updateType ); } void CClient_Precipitation::ClientThink() { Simulate( gpGlobals->frametime ); } //----------------------------------------------------------------------------- // // Utility methods for the various simulation functions // //----------------------------------------------------------------------------- inline bool CClient_Precipitation::SimulateRain( CPrecipitationParticle* pParticle, float dt ) { if (GetRemainingLifetime( pParticle ) < 0.0f) return false; Vector vOldPos = pParticle->m_Pos; // Update position VectorMA( pParticle->m_Pos, dt, pParticle->m_Velocity, pParticle->m_Pos ); // wind blows rain around for ( int i = 0 ; i < 2 ; i++ ) { if ( pParticle->m_Velocity[i] < s_WindVector[i] ) { pParticle->m_Velocity[i] += ( 5 / pParticle->m_Mass ); // clamp if ( pParticle->m_Velocity[i] > s_WindVector[i] ) pParticle->m_Velocity[i] = s_WindVector[i]; } else if (pParticle->m_Velocity[i] > s_WindVector[i] ) { pParticle->m_Velocity[i] -= ( 5 / pParticle->m_Mass ); // clamp. if ( pParticle->m_Velocity[i] < s_WindVector[i] ) pParticle->m_Velocity[i] = s_WindVector[i]; } } // No longer in the air? punt. if ( !IsInAir( pParticle->m_Pos ) ) { // Possibly make a splash if we hit a water surface and it's in front of the view. if ( m_Splashes.Count() < 20 ) { if ( RandomInt( 0, 100 ) < r_RainSplashPercentage.GetInt() ) { trace_t trace; UTIL_TraceLine(vOldPos, pParticle->m_Pos, MASK_WATER, NULL, COLLISION_GROUP_NONE, &trace); if( trace.fraction < 1 ) { m_Splashes.AddToTail( trace.endpos ); } } } // Tell the framework it's time to remove the particle from the list return false; } // We still want this particle return true; } inline bool CClient_Precipitation::SimulateSnow( CPrecipitationParticle* pParticle, float dt ) { if ( IsInAir( pParticle->m_Pos ) ) { // Update position VectorMA( pParticle->m_Pos, dt, pParticle->m_Velocity, pParticle->m_Pos ); // wind blows rain around for ( int i = 0 ; i < 2 ; i++ ) { if ( pParticle->m_Velocity[i] < s_WindVector[i] ) { pParticle->m_Velocity[i] += ( 5.0f / pParticle->m_Mass ); // accelerating flakes get a trail pParticle->m_Ramp = 0.5f; // clamp if ( pParticle->m_Velocity[i] > s_WindVector[i] ) pParticle->m_Velocity[i] = s_WindVector[i]; } else if (pParticle->m_Velocity[i] > s_WindVector[i] ) { pParticle->m_Velocity[i] -= ( 5.0f / pParticle->m_Mass ); // accelerating flakes get a trail pParticle->m_Ramp = 0.5f; // clamp. if ( pParticle->m_Velocity[i] < s_WindVector[i] ) pParticle->m_Velocity[i] = s_WindVector[i]; } } return true; } // Kill the particle immediately! return false; } void CClient_Precipitation::Simulate( float dt ) { // NOTE: When client-side prechaching works, we need to remove this Precache(); m_flHalfScreenWidth = (float)ScreenWidth() / 2; // Our sim methods needs dt and wind vector if ( dt ) { ComputeWindVector( ); } if ( m_nPrecipType == PRECIPITATION_TYPE_ASH ) { CreateAshParticle(); return; } // The snow fall manager handles the simulation. if ( m_nPrecipType == PRECIPITATION_TYPE_SNOWFALL ) return; // calculate the max amount of time it will take this flake to fall. // This works if we assume the wind doesn't have a z component if ( r_RainHack.GetInt() ) m_Lifetime = (GetClientWorldEntity()->m_WorldMaxs[2] - GetClientWorldEntity()->m_WorldMins[2]) / m_Speed; else m_Lifetime = (WorldAlignMaxs()[2] - WorldAlignMins()[2]) / m_Speed; if ( !r_RainSimulate.GetInt() ) return; CFastTimer timer; timer.Start(); // Emit new particles EmitParticles( dt ); // Simulate all the particles. int iNext; if ( m_nPrecipType == PRECIPITATION_TYPE_RAIN ) { for ( int i=m_Particles.Head(); i != m_Particles.InvalidIndex(); i=iNext ) { iNext = m_Particles.Next( i ); if ( !SimulateRain( &m_Particles[i], dt ) ) m_Particles.Remove( i ); } } else if ( m_nPrecipType == PRECIPITATION_TYPE_SNOW ) { for ( int i=m_Particles.Head(); i != m_Particles.InvalidIndex(); i=iNext ) { iNext = m_Particles.Next( i ); if ( !SimulateSnow( &m_Particles[i], dt ) ) m_Particles.Remove( i ); } } if ( r_RainProfile.GetInt() ) { timer.End(); engine->Con_NPrintf( 15, "Rain simulation: %du (%d tracers)", timer.GetDuration().GetMicroseconds(), m_Particles.Count() ); } } //----------------------------------------------------------------------------- // tracer rendering //----------------------------------------------------------------------------- inline void CClient_Precipitation::RenderParticle( CPrecipitationParticle* pParticle, CMeshBuilder &mb ) { float scale; Vector start, delta; if ( m_nPrecipType == PRECIPITATION_TYPE_ASH ) return; if ( m_nPrecipType == PRECIPITATION_TYPE_SNOWFALL ) return; // make streaks 0.1 seconds long, but prevent from going past end float lifetimeRemaining = GetRemainingLifetime( pParticle ); if (lifetimeRemaining >= GetLength()) scale = GetLength() * pParticle->m_Ramp; else scale = lifetimeRemaining * pParticle->m_Ramp; // NOTE: We need to do everything in screen space Vector3DMultiplyPosition( CurrentWorldToViewMatrix(), pParticle->m_Pos, start ); if ( start.z > -1 ) return; Vector3DMultiply( CurrentWorldToViewMatrix(), pParticle->m_Velocity, delta ); // give a spiraling pattern to snow particles if ( m_nPrecipType == PRECIPITATION_TYPE_SNOW ) { Vector spiral, camSpiral; float s, c; if ( pParticle->m_Mass > 1.0f ) { SinCos( gpGlobals->curtime * M_PI * (1+pParticle->m_Mass * 0.1f) + pParticle->m_Mass * 5.0f, &s , &c ); // only spiral particles with a mass > 1, so some fall straight down spiral[0] = 28 * c; spiral[1] = 28 * s; spiral[2] = 0.0f; Vector3DMultiply( CurrentWorldToViewMatrix(), spiral, camSpiral ); // X and Y are measured in world space; need to convert to camera space VectorAdd( start, camSpiral, start ); VectorAdd( delta, camSpiral, delta ); } // shrink the trails on spiraling flakes. pParticle->m_Ramp = 0.3f; } delta[0] *= scale; delta[1] *= scale; delta[2] *= scale; // See c_tracer.* for this method float flAlpha = r_rainalpha.GetFloat(); float flWidth = GetWidth(); float flScreenSpaceWidth = flWidth * m_flHalfScreenWidth / -start.z; if ( flScreenSpaceWidth < MIN_SCREENSPACE_RAIN_WIDTH ) { // Make the rain tracer at least the min size, but fade its alpha the smaller it gets. flAlpha *= flScreenSpaceWidth / MIN_SCREENSPACE_RAIN_WIDTH; flWidth = MIN_SCREENSPACE_RAIN_WIDTH * -start.z / m_flHalfScreenWidth; } flAlpha = pow( flAlpha, r_rainalphapow.GetFloat() ); float flColor[4] = { 1, 1, 1, flAlpha }; Tracer_Draw( &mb, start, delta, flWidth, flColor, 1 ); } void CClient_Precipitation::CreateWaterSplashes() { for ( int i=0; i < m_Splashes.Count(); i++ ) { Vector vSplash = m_Splashes[i]; if ( CurrentViewForward().Dot( vSplash - CurrentViewOrigin() ) > 1 ) { FX_WaterRipple( vSplash, g_flSplashScale, &g_vSplashColor, g_flSplashLifetime, g_flSplashAlpha ); } } m_Splashes.Purge(); } void CClient_Precipitation::Render() { if ( !r_DrawRain.GetInt() ) return; // Don't render in monitors or in reflections or refractions. if ( CurrentViewID() == VIEW_MONITOR ) return; if ( view->GetDrawFlags() & (DF_RENDER_REFLECTION | DF_RENDER_REFRACTION) ) return; if ( m_nPrecipType == PRECIPITATION_TYPE_ASH ) return; if ( m_nPrecipType == PRECIPITATION_TYPE_SNOWFALL ) return; // Create any queued up water splashes. CreateWaterSplashes(); CFastTimer timer; timer.Start(); CMatRenderContextPtr pRenderContext( materials ); // We want to do our calculations in view space. VMatrix tempView; pRenderContext->GetMatrix( MATERIAL_VIEW, &tempView ); pRenderContext->MatrixMode( MATERIAL_VIEW ); pRenderContext->LoadIdentity(); // Force the user clip planes to use the old view matrix pRenderContext->EnableUserClipTransformOverride( true ); pRenderContext->UserClipTransform( tempView ); // Draw all the rain tracers. pRenderContext->Bind( m_MatHandle ); IMesh *pMesh = pRenderContext->GetDynamicMesh(); if ( pMesh ) { CMeshBuilder mb; mb.Begin( pMesh, MATERIAL_QUADS, m_Particles.Count() ); for ( int i=m_Particles.Head(); i != m_Particles.InvalidIndex(); i=m_Particles.Next( i ) ) { CPrecipitationParticle *p = &m_Particles[i]; RenderParticle( p, mb ); } mb.End( false, true ); } pRenderContext->EnableUserClipTransformOverride( false ); pRenderContext->MatrixMode( MATERIAL_VIEW ); pRenderContext->LoadMatrix( tempView ); if ( r_RainProfile.GetInt() ) { timer.End(); engine->Con_NPrintf( 16, "Rain render : %du", timer.GetDuration().GetMicroseconds() ); } } //----------------------------------------------------------------------------- // Constructor, destructor //----------------------------------------------------------------------------- CClient_Precipitation::CClient_Precipitation() : m_Remainder(0.0f) { m_nPrecipType = PRECIPITATION_TYPE_RAIN; m_MatHandle = INVALID_MATERIAL_HANDLE; m_flHalfScreenWidth = 1; g_Precipitations.AddToTail( this ); } CClient_Precipitation::~CClient_Precipitation() { g_Precipitations.FindAndRemove( this ); SnowFallManagerDestroy(); } //----------------------------------------------------------------------------- // Precache data //----------------------------------------------------------------------------- #define SNOW_SPEED 80.0f #define RAIN_SPEED 425.0f #define RAIN_TRACER_WIDTH 0.35f #define SNOW_TRACER_WIDTH 0.7f void CClient_Precipitation::Precache( ) { if ( !m_MatHandle ) { // Compute precipitation emission speed switch( m_nPrecipType ) { case PRECIPITATION_TYPE_SNOW: m_Speed = SNOW_SPEED; m_MatHandle = materials->FindMaterial( "particle/snow", TEXTURE_GROUP_CLIENT_EFFECTS ); m_InitialRamp = 0.6f; m_Width = SNOW_TRACER_WIDTH; break; case PRECIPITATION_TYPE_RAIN: Assert( m_nPrecipType == PRECIPITATION_TYPE_RAIN ); m_Speed = RAIN_SPEED; m_MatHandle = materials->FindMaterial( "particle/rain", TEXTURE_GROUP_CLIENT_EFFECTS ); m_InitialRamp = 1.0f; m_Color[3] = 1.0f; // make translucent m_Width = RAIN_TRACER_WIDTH; break; default: m_InitialRamp = 1.0f; m_Color[3] = 1.0f; // make translucent break; } // Store off the color m_Color[0] = 1.0f; m_Color[1] = 1.0f; m_Color[2] = 1.0f; } } //----------------------------------------------------------------------------- // Gets the tracer width and speed //----------------------------------------------------------------------------- inline float CClient_Precipitation::GetWidth() const { // return m_Width; return s_rainwidth.GetFloat(); } inline float CClient_Precipitation::GetLength() const { // return m_Length; return s_rainlength.GetFloat(); } inline float CClient_Precipitation::GetSpeed() const { // return m_Speed; return s_rainspeed.GetFloat(); } //----------------------------------------------------------------------------- // Gets the remaining lifetime of the particle //----------------------------------------------------------------------------- inline float CClient_Precipitation::GetRemainingLifetime( CPrecipitationParticle* pParticle ) const { float timeSinceSpawn = gpGlobals->curtime - pParticle->m_SpawnTime; return m_Lifetime - timeSinceSpawn; } //----------------------------------------------------------------------------- // Creates a particle //----------------------------------------------------------------------------- inline CPrecipitationParticle* CClient_Precipitation::CreateParticle() { int i = m_Particles.AddToTail(); CPrecipitationParticle* pParticle = &m_Particles[i]; pParticle->m_SpawnTime = gpGlobals->curtime; pParticle->m_Ramp = m_InitialRamp; return pParticle; } //----------------------------------------------------------------------------- // Compute the emission area //----------------------------------------------------------------------------- bool CClient_Precipitation::ComputeEmissionArea( Vector& origin, Vector2D& size ) { // FIXME: Compute the precipitation area based on computational power float emissionSize = r_RainRadius.GetFloat(); // size of box to emit particles in Vector vMins = WorldAlignMins(); Vector vMaxs = WorldAlignMaxs(); if ( r_RainHack.GetInt() ) { vMins = GetClientWorldEntity()->m_WorldMins; vMaxs = GetClientWorldEntity()->m_WorldMaxs; } // calculate a volume around the player to snow in. Intersect this big magic // box around the player with the volume of the current environmental ent. C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( !pPlayer ) return false; // Determine how much time it'll take a falling particle to hit the player float emissionHeight = MIN( vMaxs[2], pPlayer->GetAbsOrigin()[2] + 512 ); float distToFall = emissionHeight - pPlayer->GetAbsOrigin()[2]; float fallTime = distToFall / GetSpeed(); // Based on the windspeed, figure out the center point of the emission Vector2D center; center[0] = pPlayer->GetAbsOrigin()[0] - fallTime * s_WindVector[0]; center[1] = pPlayer->GetAbsOrigin()[1] - fallTime * s_WindVector[1]; Vector2D lobound, hibound; lobound[0] = center[0] - emissionSize * 0.5f; lobound[1] = center[1] - emissionSize * 0.5f; hibound[0] = lobound[0] + emissionSize; hibound[1] = lobound[1] + emissionSize; // Cull non-intersecting. if ( ( vMaxs[0] < lobound[0] ) || ( vMaxs[1] < lobound[1] ) || ( vMins[0] > hibound[0] ) || ( vMins[1] > hibound[1] ) ) return false; origin[0] = MAX( vMins[0], lobound[0] ); origin[1] = MAX( vMins[1], lobound[1] ); origin[2] = emissionHeight; hibound[0] = MIN( vMaxs[0], hibound[0] ); hibound[1] = MIN( vMaxs[1], hibound[1] ); size[0] = hibound[0] - origin[0]; size[1] = hibound[1] - origin[1]; return true; } //----------------------------------------------------------------------------- // Purpose: // Input : *pDebugName - // Output : AshDebrisEffect* //----------------------------------------------------------------------------- AshDebrisEffect* AshDebrisEffect::Create( const char *pDebugName ) { return new AshDebrisEffect( pDebugName ); } //----------------------------------------------------------------------------- // Purpose: // Input : *pParticle - // timeDelta - // Output : float //----------------------------------------------------------------------------- float AshDebrisEffect::UpdateAlpha( const SimpleParticle *pParticle ) { return ( ((float)pParticle->m_uchStartAlpha/255.0f) * sin( M_PI * (pParticle->m_flLifetime / pParticle->m_flDieTime) ) ); } #define ASH_PARTICLE_NOISE 0x4 float AshDebrisEffect::UpdateRoll( SimpleParticle *pParticle, float timeDelta ) { float flRoll = CSimpleEmitter::UpdateRoll(pParticle, timeDelta ); if ( pParticle->m_iFlags & ASH_PARTICLE_NOISE ) { Vector vTempEntVel = pParticle->m_vecVelocity; float fastFreq = gpGlobals->curtime * 1.5; float s, c; SinCos( fastFreq, &s, &c ); pParticle->m_Pos = ( pParticle->m_Pos + Vector( vTempEntVel[0] * timeDelta * s, vTempEntVel[1] * timeDelta * s, 0 ) ); } return flRoll; } void CClient_Precipitation::CreateAshParticle( void ) { // Make sure the emitter is setup if ( m_pAshEmitter == NULL ) { if ( ( m_pAshEmitter = AshDebrisEffect::Create( "ashtray" ) ) == NULL ) return; m_tAshParticleTimer.Init( 192 ); m_tAshParticleTraceTimer.Init( 15 ); m_bActiveAshEmitter = false; m_iAshCount = 0; } C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( pPlayer == NULL ) return; Vector vForward; pPlayer->GetVectors( &vForward, NULL, NULL ); vForward.z = 0.0f; float curTime = gpGlobals->frametime; Vector vPushOrigin; Vector absmins = WorldAlignMins(); Vector absmaxs = WorldAlignMaxs(); //15 Traces a second. while ( m_tAshParticleTraceTimer.NextEvent( curTime ) ) { trace_t tr; Vector vTraceStart = pPlayer->EyePosition(); Vector vTraceEnd = pPlayer->EyePosition() + vForward * MAX_TRACE_LENGTH; UTIL_TraceLine( vTraceStart, vTraceEnd, MASK_SHOT_HULL & (~CONTENTS_GRATE), pPlayer, COLLISION_GROUP_NONE, &tr ); //debugoverlay->AddLineOverlay( vTraceStart, tr.endpos, 255, 0, 0, 0, 0.2 ); if ( tr.fraction != 1.0f ) { trace_t tr2; UTIL_TraceModel( vTraceStart, tr.endpos, Vector( -1, -1, -1 ), Vector( 1, 1, 1 ), this, COLLISION_GROUP_NONE, &tr2 ); if ( tr2.m_pEnt == this ) { m_bActiveAshEmitter = true; if ( tr2.startsolid == false ) { m_vAshSpawnOrigin = tr2.endpos + vForward * 256; } else { m_vAshSpawnOrigin = vTraceStart; } } else { m_bActiveAshEmitter = false; } } } if ( m_bActiveAshEmitter == false ) return; Vector vecVelocity = pPlayer->GetAbsVelocity(); float flVelocity = VectorNormalize( vecVelocity ); Vector offset = m_vAshSpawnOrigin; m_pAshEmitter->SetSortOrigin( offset ); PMaterialHandle hMaterial[4]; hMaterial[0] = ParticleMgr()->GetPMaterial( "effects/fleck_ash1" ); hMaterial[1] = ParticleMgr()->GetPMaterial( "effects/fleck_ash2" ); hMaterial[2] = ParticleMgr()->GetPMaterial( "effects/fleck_ash3" ); hMaterial[3] = ParticleMgr()->GetPMaterial( "effects/ember_swirling001" ); SimpleParticle *pParticle; Vector vSpawnOrigin = vec3_origin; if ( flVelocity > 0 ) { vSpawnOrigin = ( vForward * 256 ) + ( vecVelocity * ( flVelocity * 2 ) ); } // Add as many particles as we need while ( m_tAshParticleTimer.NextEvent( curTime ) ) { int iRandomAltitude = RandomInt( 0, 128 ); offset = m_vAshSpawnOrigin + vSpawnOrigin + RandomVector( -256, 256 ); offset.z = m_vAshSpawnOrigin.z + iRandomAltitude; if ( offset[0] > absmaxs[0] || offset[1] > absmaxs[1] || offset[2] > absmaxs[2] || offset[0] < absmins[0] || offset[1] < absmins[1] || offset[2] < absmins[2] ) continue; m_iAshCount++; bool bEmberTime = false; if ( m_iAshCount >= 250 ) { bEmberTime = true; m_iAshCount = 0; } int iRandom = random->RandomInt(0,2); if ( bEmberTime == true ) { offset = m_vAshSpawnOrigin + (vForward * 256) + RandomVector( -128, 128 ); offset.z = pPlayer->EyePosition().z + RandomFloat( -16, 64 ); iRandom = 3; } pParticle = (SimpleParticle *) m_pAshEmitter->AddParticle( sizeof(SimpleParticle), hMaterial[iRandom], offset ); if (pParticle == NULL) continue; pParticle->m_flLifetime = 0.0f; pParticle->m_flDieTime = RemapVal( iRandomAltitude, 0, 128, 4, 8 ); if ( bEmberTime == true ) { Vector vGoal = pPlayer->EyePosition() + RandomVector( -64, 64 ); Vector vDir = vGoal - offset; VectorNormalize( vDir ); pParticle->m_vecVelocity = vDir * 75; pParticle->m_flDieTime = 2.5f; } else { pParticle->m_vecVelocity = Vector( RandomFloat( -20.0f, 20.0f ), RandomFloat( -20.0f, 20.0f ), RandomFloat( -10, -15 ) ); } float color = random->RandomInt( 125, 225 ); pParticle->m_uchColor[0] = color; pParticle->m_uchColor[1] = color; pParticle->m_uchColor[2] = color; pParticle->m_uchStartSize = 1; pParticle->m_uchEndSize = 1; pParticle->m_uchStartAlpha = 255; pParticle->m_flRoll = random->RandomInt( 0, 360 ); pParticle->m_flRollDelta = random->RandomFloat( -0.15f, 0.15f ); pParticle->m_iFlags = SIMPLE_PARTICLE_FLAG_WINDBLOWN; if ( random->RandomInt( 0, 10 ) <= 1 ) { pParticle->m_iFlags |= ASH_PARTICLE_NOISE; } } } void CClient_Precipitation::CreateRainOrSnowParticle( Vector vSpawnPosition, Vector vVelocity ) { // Create the particle CPrecipitationParticle* p = CreateParticle(); if (!p) return; VectorCopy( vVelocity, p->m_Velocity ); p->m_Pos = vSpawnPosition; p->m_Velocity[ 0 ] += random->RandomFloat(-r_RainSideVel.GetInt(), r_RainSideVel.GetInt()); p->m_Velocity[ 1 ] += random->RandomFloat(-r_RainSideVel.GetInt(), r_RainSideVel.GetInt()); p->m_Mass = random->RandomFloat( 0.5, 1.5 ); } //----------------------------------------------------------------------------- // emit the precipitation particles //----------------------------------------------------------------------------- void CClient_Precipitation::EmitParticles( float fTimeDelta ) { Vector2D size; Vector vel, org; C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( !pPlayer ) return; Vector vPlayerCenter = pPlayer->WorldSpaceCenter(); // Compute where to emit if (!ComputeEmissionArea( org, size )) return; // clamp this to prevent creating a bunch of rain or snow at one time. if( fTimeDelta > 0.075f ) fTimeDelta = 0.075f; // FIXME: Compute the precipitation density based on computational power float density = m_flDensity; if (density > 0.01f) density = 0.01f; // Compute number of particles to emit based on precip density and emission area and dt float fParticles = size[0] * size[1] * density * fTimeDelta + m_Remainder; int cParticles = (int)fParticles; m_Remainder = fParticles - cParticles; // calculate the max amount of time it will take this flake to fall. // This works if we assume the wind doesn't have a z component VectorCopy( s_WindVector, vel ); vel[2] -= GetSpeed(); // Emit all the particles for ( int i = 0 ; i < cParticles ; i++ ) { Vector vParticlePos = org; vParticlePos[ 0 ] += size[ 0 ] * random->RandomFloat(0, 1); vParticlePos[ 1 ] += size[ 1 ] * random->RandomFloat(0, 1); // Figure out where the particle should lie in Z by tracing a line from the player's height up to the // desired height and making sure it doesn't hit a wall. Vector vPlayerHeight = vParticlePos; vPlayerHeight.z = vPlayerCenter.z; trace_t trace; UTIL_TraceLine( vPlayerHeight, vParticlePos, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace ); if ( trace.fraction < 1 ) { // If we hit a brush, then don't spawn the particle. if ( trace.surface.flags & SURF_SKY ) { vParticlePos = trace.endpos; } else { continue; } } CreateRainOrSnowParticle( vParticlePos, vel ); } } //----------------------------------------------------------------------------- // Computes the wind vector //----------------------------------------------------------------------------- void CClient_Precipitation::ComputeWindVector( ) { // Compute the wind direction QAngle windangle( 0, cl_winddir.GetFloat(), 0 ); // used to turn wind yaw direction into a vector // Randomize the wind angle and speed slightly to get us a little variation windangle[1] = windangle[1] + random->RandomFloat( -10, 10 ); float windspeed = cl_windspeed.GetFloat() * (1.0 + random->RandomFloat( -0.2, 0.2 )); AngleVectors( windangle, &s_WindVector ); VectorScale( s_WindVector, windspeed, s_WindVector ); } CHandle g_pPrecipHackEnt; class CPrecipHack : public CAutoGameSystemPerFrame { public: CPrecipHack( char const *name ) : CAutoGameSystemPerFrame( name ) { m_bLevelInitted = false; } virtual void LevelInitPostEntity() { if ( r_RainHack.GetInt() ) { CClient_Precipitation *pPrecipHackEnt = new CClient_Precipitation; pPrecipHackEnt->InitializeAsClientEntity( NULL, RENDER_GROUP_TRANSLUCENT_ENTITY ); g_pPrecipHackEnt = pPrecipHackEnt; } m_bLevelInitted = true; } virtual void LevelShutdownPreEntity() { if ( r_RainHack.GetInt() && g_pPrecipHackEnt ) { g_pPrecipHackEnt->Release(); } m_bLevelInitted = false; } virtual void Update( float frametime ) { // Handle changes to the cvar at runtime. if ( m_bLevelInitted ) { if ( r_RainHack.GetInt() && !g_pPrecipHackEnt ) LevelInitPostEntity(); else if ( !r_RainHack.GetInt() && g_pPrecipHackEnt ) LevelShutdownPreEntity(); } } bool m_bLevelInitted; }; CPrecipHack g_PrecipHack( "CPrecipHack" ); #else void DrawPrecipitation() { } #endif // _XBOX //----------------------------------------------------------------------------- // EnvWind - global wind info //----------------------------------------------------------------------------- class C_EnvWind : public C_BaseEntity { public: C_EnvWind(); DECLARE_CLIENTCLASS(); DECLARE_CLASS( C_EnvWind, C_BaseEntity ); virtual void OnDataChanged( DataUpdateType_t updateType ); virtual bool ShouldDraw( void ) { return false; } virtual void ClientThink( ); private: C_EnvWind( const C_EnvWind & ); CEnvWindShared m_EnvWindShared; }; // Receive datatables BEGIN_RECV_TABLE_NOBASE(CEnvWindShared, DT_EnvWindShared) RecvPropInt (RECVINFO(m_iMinWind)), RecvPropInt (RECVINFO(m_iMaxWind)), RecvPropInt (RECVINFO(m_iMinGust)), RecvPropInt (RECVINFO(m_iMaxGust)), RecvPropFloat (RECVINFO(m_flMinGustDelay)), RecvPropFloat (RECVINFO(m_flMaxGustDelay)), RecvPropInt (RECVINFO(m_iGustDirChange)), RecvPropInt (RECVINFO(m_iWindSeed)), RecvPropInt (RECVINFO(m_iInitialWindDir)), RecvPropFloat (RECVINFO(m_flInitialWindSpeed)), RecvPropFloat (RECVINFO(m_flStartTime)), RecvPropFloat (RECVINFO(m_flGustDuration)), // RecvPropInt (RECVINFO(m_iszGustSound)), END_RECV_TABLE() IMPLEMENT_CLIENTCLASS_DT( C_EnvWind, DT_EnvWind, CEnvWind ) RecvPropDataTable(RECVINFO_DT(m_EnvWindShared), 0, &REFERENCE_RECV_TABLE(DT_EnvWindShared)), END_RECV_TABLE() C_EnvWind::C_EnvWind() { } //----------------------------------------------------------------------------- // Post data update! //----------------------------------------------------------------------------- void C_EnvWind::OnDataChanged( DataUpdateType_t updateType ) { // Whenever we get an update, reset the entire state. // Note that the fields have already been stored by the datatables, // but there's still work to be done in the init block m_EnvWindShared.Init( entindex(), m_EnvWindShared.m_iWindSeed, m_EnvWindShared.m_flStartTime, m_EnvWindShared.m_iInitialWindDir, m_EnvWindShared.m_flInitialWindSpeed ); SetNextClientThink(0.0f); BaseClass::OnDataChanged( updateType ); } void C_EnvWind::ClientThink( ) { // Update the wind speed float flNextThink = m_EnvWindShared.WindThink( gpGlobals->curtime ); SetNextClientThink(flNextThink); } //================================================== // EmberParticle //================================================== class CEmberEmitter : public CSimpleEmitter { public: CEmberEmitter( const char *pDebugName ); static CSmartPtr Create( const char *pDebugName ); virtual void UpdateVelocity( SimpleParticle *pParticle, float timeDelta ); virtual Vector UpdateColor( const SimpleParticle *pParticle ); private: CEmberEmitter( const CEmberEmitter & ); }; //----------------------------------------------------------------------------- // Purpose: // Input : fTimeDelta - // Output : Vector //----------------------------------------------------------------------------- CEmberEmitter::CEmberEmitter( const char *pDebugName ) : CSimpleEmitter( pDebugName ) { } CSmartPtr CEmberEmitter::Create( const char *pDebugName ) { return new CEmberEmitter( pDebugName ); } void CEmberEmitter::UpdateVelocity( SimpleParticle *pParticle, float timeDelta ) { float speed = VectorNormalize( pParticle->m_vecVelocity ); Vector offset; speed -= ( 1.0f * timeDelta ); offset.Random( -0.025f, 0.025f ); offset[2] = 0.0f; pParticle->m_vecVelocity += offset; VectorNormalize( pParticle->m_vecVelocity ); pParticle->m_vecVelocity *= speed; } //----------------------------------------------------------------------------- // Purpose: // Input : *pParticle - // timeDelta - //----------------------------------------------------------------------------- Vector CEmberEmitter::UpdateColor( const SimpleParticle *pParticle ) { Vector color; float ramp = 1.0f - ( pParticle->m_flLifetime / pParticle->m_flDieTime ); color[0] = ( (float) pParticle->m_uchColor[0] * ramp ) / 255.0f; color[1] = ( (float) pParticle->m_uchColor[1] * ramp ) / 255.0f; color[2] = ( (float) pParticle->m_uchColor[2] * ramp ) / 255.0f; return color; } //================================================== // C_Embers //================================================== class C_Embers : public C_BaseEntity { public: DECLARE_CLIENTCLASS(); DECLARE_CLASS( C_Embers, C_BaseEntity ); C_Embers(); ~C_Embers(); void Start( void ); virtual void OnDataChanged( DataUpdateType_t updateType ); virtual bool ShouldDraw( void ); virtual void AddEntity( void ); //Server-side int m_nDensity; int m_nLifetime; int m_nSpeed; bool m_bEmit; protected: void SpawnEmber( void ); PMaterialHandle m_hMaterial; TimedEvent m_tParticleSpawn; CSmartPtr m_pEmitter; }; //Receive datatable IMPLEMENT_CLIENTCLASS_DT( C_Embers, DT_Embers, CEmbers ) RecvPropInt( RECVINFO( m_nDensity ) ), RecvPropInt( RECVINFO( m_nLifetime ) ), RecvPropInt( RECVINFO( m_nSpeed ) ), RecvPropInt( RECVINFO( m_bEmit ) ), END_RECV_TABLE() //----------------------------------------------------------------------------- // Purpose: // Input : bnewentity - //----------------------------------------------------------------------------- C_Embers::C_Embers() { m_pEmitter = CEmberEmitter::Create( "C_Embers" ); } C_Embers::~C_Embers() { } void C_Embers::OnDataChanged( DataUpdateType_t updateType ) { BaseClass::OnDataChanged( updateType ); if ( updateType == DATA_UPDATE_CREATED ) { m_pEmitter->SetSortOrigin( GetAbsOrigin() ); Start(); } } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool C_Embers::ShouldDraw() { return true; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void C_Embers::Start( void ) { //Various setup info m_tParticleSpawn.Init( m_nDensity ); m_hMaterial = m_pEmitter->GetPMaterial( "particle/fire" ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void C_Embers::AddEntity( void ) { if ( m_bEmit == false ) return; float tempDelta = gpGlobals->frametime; while( m_tParticleSpawn.NextEvent( tempDelta ) ) { SpawnEmber(); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void C_Embers::SpawnEmber( void ) { Vector offset, mins, maxs; modelinfo->GetModelBounds( GetModel(), mins, maxs ); //Setup our spawn position offset[0] = random->RandomFloat( mins[0], maxs[0] ); offset[1] = random->RandomFloat( mins[1], maxs[1] ); offset[2] = random->RandomFloat( mins[2], maxs[2] ); //Spawn the particle SimpleParticle *sParticle = (SimpleParticle *) m_pEmitter->AddParticle( sizeof( SimpleParticle ), m_hMaterial, offset ); if (sParticle == NULL) return; float cScale = random->RandomFloat( 0.75f, 1.0f ); //Set it up sParticle->m_flLifetime = 0.0f; sParticle->m_flDieTime = m_nLifetime; sParticle->m_uchColor[0] = m_clrRender->r * cScale; sParticle->m_uchColor[1] = m_clrRender->g * cScale; sParticle->m_uchColor[2] = m_clrRender->b * cScale; sParticle->m_uchStartAlpha = 255; sParticle->m_uchEndAlpha = 0; sParticle->m_uchStartSize = 1; sParticle->m_uchEndSize = 0; sParticle->m_flRollDelta = 0; sParticle->m_flRoll = 0; //Set the velocity Vector velocity; AngleVectors( GetAbsAngles(), &velocity ); sParticle->m_vecVelocity = velocity * m_nSpeed; sParticle->m_vecVelocity[0] += random->RandomFloat( -(m_nSpeed/8), (m_nSpeed/8) ); sParticle->m_vecVelocity[1] += random->RandomFloat( -(m_nSpeed/8), (m_nSpeed/8) ); sParticle->m_vecVelocity[2] += random->RandomFloat( -(m_nSpeed/8), (m_nSpeed/8) ); UpdateVisibility(); } //----------------------------------------------------------------------------- // Quadratic spline beam effect //----------------------------------------------------------------------------- #include "beamdraw.h" class C_QuadraticBeam : public C_BaseEntity { public: DECLARE_CLIENTCLASS(); DECLARE_CLASS( C_QuadraticBeam, C_BaseEntity ); //virtual void OnDataChanged( DataUpdateType_t updateType ); virtual bool ShouldDraw( void ) { return true; } virtual int DrawModel( int ); virtual void GetRenderBounds( Vector& mins, Vector& maxs ) { ClearBounds( mins, maxs ); AddPointToBounds( vec3_origin, mins, maxs ); AddPointToBounds( m_targetPosition, mins, maxs ); AddPointToBounds( m_controlPosition, mins, maxs ); mins -= GetRenderOrigin(); maxs -= GetRenderOrigin(); } protected: Vector m_targetPosition; Vector m_controlPosition; float m_scrollRate; float m_flWidth; }; //Receive datatable IMPLEMENT_CLIENTCLASS_DT( C_QuadraticBeam, DT_QuadraticBeam, CEnvQuadraticBeam ) RecvPropVector( RECVINFO(m_targetPosition) ), RecvPropVector( RECVINFO(m_controlPosition) ), RecvPropFloat( RECVINFO(m_scrollRate) ), RecvPropFloat( RECVINFO(m_flWidth) ), END_RECV_TABLE() Vector Color32ToVector( const color32 &color ) { return Vector( color.r * (1.0/255.0f), color.g * (1.0/255.0f), color.b * (1.0/255.0f) ); } int C_QuadraticBeam::DrawModel( int ) { Draw_SetSpriteTexture( GetModel(), 0, GetRenderMode() ); Vector color = Color32ToVector( GetRenderColor() ); DrawBeamQuadratic( GetRenderOrigin(), m_controlPosition, m_targetPosition, m_flWidth, color, gpGlobals->curtime*m_scrollRate ); return 1; } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- class SnowFallEffect : public CSimpleEmitter { public: SnowFallEffect( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {} static SnowFallEffect* Create( const char *pDebugName ) { return new SnowFallEffect( pDebugName ); } void UpdateVelocity( SimpleParticle *pParticle, float timeDelta ) { float flSpeed = VectorNormalize( pParticle->m_vecVelocity ); flSpeed -= timeDelta; pParticle->m_vecVelocity.x += RandomFloat( -0.025f, 0.025f ); pParticle->m_vecVelocity.y += RandomFloat( -0.025f, 0.025f ); VectorNormalize( pParticle->m_vecVelocity ); pParticle->m_vecVelocity *= flSpeed; Vector vecWindVelocity; GetWindspeedAtTime( gpGlobals->curtime, vecWindVelocity ); pParticle->m_vecVelocity += ( vecWindVelocity * r_SnowWindScale.GetFloat() ); } void SimulateParticles( CParticleSimulateIterator *pIterator ) { float timeDelta = pIterator->GetTimeDelta(); SimpleParticle *pParticle = (SimpleParticle*)pIterator->GetFirst(); while ( pParticle ) { //Update velocity UpdateVelocity( pParticle, timeDelta ); pParticle->m_Pos += pParticle->m_vecVelocity * timeDelta; //Should this particle die? pParticle->m_flLifetime += timeDelta; UpdateRoll( pParticle, timeDelta ); if ( pParticle->m_flLifetime >= pParticle->m_flDieTime ) { pIterator->RemoveParticle( pParticle ); } else if ( !IsInAir( pParticle->m_Pos ) ) { pIterator->RemoveParticle( pParticle ); } pParticle = (SimpleParticle*)pIterator->GetNext(); } } int GetParticleCount( void ) { return GetBinding().GetNumActiveParticles(); } void SetBounds( const Vector &vecMin, const Vector &vecMax ) { GetBinding().SetBBox( vecMin, vecMax, true ); } bool IsTransparent( void ) { return false; } private: SnowFallEffect( const SnowFallEffect & ); }; //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- class CSnowFallManager : public C_BaseEntity { public: CSnowFallManager(); ~CSnowFallManager(); bool CreateEmitter( void ); void SpawnClientEntity( void ); void ClientThink(); void AddSnowFallEntity( CClient_Precipitation *pSnowEntity ); // Snow Effect enum { SNOWFALL_NONE = 0, SNOWFALL_AROUND_PLAYER, SNOWFALL_IN_ENTITY, }; bool IsTransparent( void ) { return false; } private: bool CreateSnowFallEmitter( void ); void CreateSnowFall( void ); void CreateSnowFallParticles( float flCurrentTime, float flRadius, const Vector &vecEyePos, const Vector &vecForward, float flZoomScale ); void CreateOutsideVolumeSnowParticles( float flCurrentTime, float flRadius, float flZoomScale ); void CreateInsideVolumeSnowParticles( float flCurrentTime, float flRadius, const Vector &vecEyePos, const Vector &vecForward, float flZoomScale ); void CreateSnowParticlesSphere( float flRadius ); void CreateSnowParticlesRay( float flRadius, const Vector &vecEyePos, const Vector &vecForward ); void CreateSnowFallParticle( const Vector &vecParticleSpawn, int iBBox ); int StandingInSnowVolume( Vector &vecPoint ); void FindSnowVolumes( Vector &vecCenter, float flRadius, Vector &vecEyePos, Vector &vecForward ); void UpdateBounds( const Vector &vecSnowMin, const Vector &vecSnowMax ); private: enum { MAX_SNOW_PARTICLES = 500 }; enum { MAX_SNOW_LIST = 32 }; TimedEvent m_tSnowFallParticleTimer; TimedEvent m_tSnowFallParticleTraceTimer; int m_iSnowFallArea; CSmartPtr m_pSnowFallEmitter; Vector m_vecSnowFallEmitOrigin; float m_flSnowRadius; Vector m_vecMin; Vector m_vecMax; int m_nActiveSnowCount; int m_aActiveSnow[MAX_SNOW_LIST]; bool m_bRayParticles; struct SnowFall_t { PMaterialHandle m_hMaterial; CClient_Precipitation *m_pEntity; SnowFallEffect *m_pEffect; Vector m_vecMin; Vector m_vecMax; }; CUtlVector m_aSnow; }; //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CSnowFallManager::CSnowFallManager( void ) { m_iSnowFallArea = SNOWFALL_NONE; m_pSnowFallEmitter = NULL; m_vecSnowFallEmitOrigin.Init(); m_flSnowRadius = 0.0f; m_vecMin.Init( FLT_MAX, FLT_MAX, FLT_MAX ); m_vecMax.Init( FLT_MIN, FLT_MIN, FLT_MIN ); m_nActiveSnowCount = 0; m_aSnow.Purge(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CSnowFallManager::~CSnowFallManager( void ) { m_aSnow.Purge(); } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CSnowFallManager::CreateEmitter( void ) { return CreateSnowFallEmitter(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CSnowFallManager::SpawnClientEntity( void ) { m_tSnowFallParticleTimer.Init( 500 ); m_tSnowFallParticleTraceTimer.Init( 6 ); m_iSnowFallArea = SNOWFALL_NONE; // Have the Snow Fall Manager think for all the snow fall entities. SetNextClientThink( CLIENT_THINK_ALWAYS ); } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CSnowFallManager::CreateSnowFallEmitter( void ) { if ( ( m_pSnowFallEmitter = SnowFallEffect::Create( "snowfall" ) ) == NULL ) return false; return true; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CSnowFallManager::ClientThink( void ) { if ( !r_SnowEnable.GetBool() ) return; // Make sure we have a snow fall emitter. if ( !m_pSnowFallEmitter ) { if ( !CreateSnowFallEmitter() ) return; } CreateSnowFall(); } //----------------------------------------------------------------------------- // Purpose: // Input : *pSnowEntity - //----------------------------------------------------------------------------- void CSnowFallManager::AddSnowFallEntity( CClient_Precipitation *pSnowEntity ) { if ( !pSnowEntity ) return; int nSnowCount = m_aSnow.Count(); int iSnow = 0; for ( iSnow = 0; iSnow < nSnowCount; ++iSnow ) { if ( m_aSnow[iSnow].m_pEntity == pSnowEntity ) break; } if ( iSnow != nSnowCount ) return; iSnow = m_aSnow.AddToTail(); m_aSnow[iSnow].m_pEntity = pSnowEntity; m_aSnow[iSnow].m_pEffect = SnowFallEffect::Create( "snowfall" ); m_aSnow[iSnow].m_hMaterial = ParticleMgr()->GetPMaterial( "particle/snow" ); VectorCopy( pSnowEntity->WorldAlignMins(), m_aSnow[iSnow].m_vecMin ); VectorCopy( pSnowEntity->WorldAlignMaxs(), m_aSnow[iSnow].m_vecMax ); UpdateBounds( m_aSnow[iSnow].m_vecMin, m_aSnow[iSnow].m_vecMax ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CSnowFallManager::UpdateBounds( const Vector &vecSnowMin, const Vector &vecSnowMax ) { int iAxis = 0; for ( iAxis = 0; iAxis < 3; ++iAxis ) { if ( vecSnowMin[iAxis] < m_vecMin[iAxis] ) { m_vecMin[iAxis] = vecSnowMin[iAxis]; } if ( vecSnowMax[iAxis] > m_vecMax[iAxis] ) { m_vecMax[iAxis] = vecSnowMax[iAxis]; } } Assert( m_pSnowFallEmitter ); m_pSnowFallEmitter->SetBounds( m_vecMin, m_vecMax ); } //----------------------------------------------------------------------------- // Purpose: // Input : &vecPoint - // Output : int //----------------------------------------------------------------------------- int CSnowFallManager::StandingInSnowVolume( Vector &vecPoint ) { trace_t traceSnow; int nSnowCount = m_aSnow.Count(); int iSnow = 0; for ( iSnow = 0; iSnow < nSnowCount; ++iSnow ) { UTIL_TraceModel( vecPoint, vecPoint, vec3_origin, vec3_origin, static_cast( m_aSnow[iSnow].m_pEntity ), COLLISION_GROUP_NONE, &traceSnow ); if ( traceSnow.startsolid ) return iSnow; } return -1; } //----------------------------------------------------------------------------- // Purpose: // Input : &vecCenter - // flRadius - //----------------------------------------------------------------------------- void CSnowFallManager::FindSnowVolumes( Vector &vecCenter, float flRadius, Vector &vecEyePos, Vector &vecForward ) { // Reset. m_nActiveSnowCount = 0; m_bRayParticles = false; int nSnowCount = m_aSnow.Count(); int iSnow = 0; for ( iSnow = 0; iSnow < nSnowCount; ++iSnow ) { // Check to see if the volume is in the PVS. bool bInPVS = g_pClientLeafSystem->IsRenderableInPVS( m_aSnow[iSnow].m_pEntity->GetClientRenderable() ); if ( !bInPVS ) continue; // Check to see if a snow volume is inside the given radius. if ( IsBoxIntersectingSphere( m_aSnow[iSnow].m_vecMin, m_aSnow[iSnow].m_vecMax, vecCenter, flRadius ) ) { m_aActiveSnow[m_nActiveSnowCount] = iSnow; ++m_nActiveSnowCount; if ( m_nActiveSnowCount >= MAX_SNOW_LIST ) { DevWarning( 1, "Max Active Snow Volume Count!\n" ); break; } } // Check to see if a snow volume is outside of the sphere radius, but is along line-of-sight. else { CBaseTrace trace; Vector vecNewForward; vecNewForward = vecForward * r_SnowRayLength.GetFloat(); vecNewForward.z = 0.0f; IntersectRayWithBox( vecEyePos, vecNewForward, m_aSnow[iSnow].m_vecMin, m_aSnow[iSnow].m_vecMax, 0.325f, &trace ); if ( trace.fraction < 1.0f ) { m_aActiveSnow[m_nActiveSnowCount] = iSnow; ++m_nActiveSnowCount; if ( m_nActiveSnowCount >= MAX_SNOW_LIST ) { DevWarning( 1, "Max Active Snow Volume Count!\n" ); break; } m_bRayParticles = true; } } } // Debugging code! #ifdef _DEBUG if ( r_SnowDebugBox.GetFloat() != 0.0f ) { for ( iSnow = 0; iSnow < m_nActiveSnowCount; ++iSnow ) { Vector vecMin, vecMax; vecCenter = ( m_aSnow[iSnow].m_vecMin, m_aSnow[iSnow].m_vecMax ) * 0.5; vecMin = m_aSnow[iSnow].m_vecMin - vecCenter; vecMax = m_aSnow[iSnow].m_vecMax - vecCenter; if ( debugoverlay ) { debugoverlay->AddBoxOverlay( vecCenter, vecMin, vecMax, QAngle( 0, 0, 0 ), 200, 0, 0, 25, r_SnowDebugBox.GetFloat() ); } } } #endif } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CSnowFallManager::CreateSnowFall( void ) { #if 1 VPROF_BUDGET( "SnowFall", VPROF_BUDGETGROUP_PARTICLE_RENDERING ); #endif // Check to see if we have a local player before starting the snow around a local player. C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( pPlayer == NULL ) return; // Get the current frame time. float flCurrentTime = gpGlobals->frametime; // Get the players data to determine where the snow emitter should reside. VectorCopy( pPlayer->EyePosition(), m_vecSnowFallEmitOrigin ); Vector vecForward; pPlayer->GetVectors( &vecForward, NULL, NULL ); vecForward.z = 0.0f; Vector vecVelocity = pPlayer->GetAbsVelocity(); float flSpeed = VectorNormalize( vecVelocity ); m_vecSnowFallEmitOrigin += ( vecForward * ( 64.0f + ( flSpeed * 0.4f * r_SnowPosScale.GetFloat() ) ) ); m_vecSnowFallEmitOrigin += ( vecVelocity * ( flSpeed * 1.25f * r_SnowSpeedScale.GetFloat() ) ); // Check to see if the player is zoomed. bool bZoomed = ( pPlayer->GetFOV() != pPlayer->GetDefaultFOV() ); float flZoomScale = 1.0f; if ( bZoomed ) { flZoomScale = pPlayer->GetDefaultFOV() / pPlayer->GetFOV(); flZoomScale *= 0.5f; } // Time to test for a snow volume yet? (Only do this 6 times a second!) if ( m_tSnowFallParticleTraceTimer.NextEvent( flCurrentTime ) ) { // Reset the active snow emitter. m_iSnowFallArea = SNOWFALL_NONE; // Set the trace start and the emit origin. Vector vecTraceStart; VectorCopy( pPlayer->EyePosition(), vecTraceStart ); int iSnowVolume = StandingInSnowVolume( vecTraceStart ); if ( iSnowVolume != -1 ) { m_flSnowRadius = r_SnowInsideRadius.GetFloat() + ( flSpeed * 0.5f ); m_iSnowFallArea = SNOWFALL_AROUND_PLAYER; } else { m_flSnowRadius = r_SnowOutsideRadius.GetFloat(); } float flRadius = m_flSnowRadius; if ( bZoomed ) { if ( m_iSnowFallArea == SNOWFALL_AROUND_PLAYER ) { flRadius = r_SnowOutsideRadius.GetFloat() * flZoomScale; } else { flRadius *= flZoomScale; } } Vector vecEyePos = pPlayer->EyePosition(); FindSnowVolumes( m_vecSnowFallEmitOrigin, flRadius, vecEyePos, vecForward ); if ( m_nActiveSnowCount != 0 && m_iSnowFallArea != SNOWFALL_AROUND_PLAYER ) { // We found an active snow emitter. m_iSnowFallArea = SNOWFALL_IN_ENTITY; } } if ( m_iSnowFallArea == SNOWFALL_NONE ) return; // Set the origin in the snow emitter. m_pSnowFallEmitter->SetSortOrigin( m_vecSnowFallEmitOrigin ); // Create snow fall particles. CreateSnowFallParticles( flCurrentTime, m_flSnowRadius, pPlayer->EyePosition(), vecForward, flZoomScale ); } //----------------------------------------------------------------------------- // Purpose: // Input : flCurrentTime - // flRadius - // &vecEyePos - // &vecForward - // flZoomScale - //----------------------------------------------------------------------------- void CSnowFallManager::CreateSnowFallParticles( float flCurrentTime, float flRadius, const Vector &vecEyePos, const Vector &vecForward, float flZoomScale ) { // Outside of a snow volume. if ( m_iSnowFallArea == SNOWFALL_IN_ENTITY ) { CreateOutsideVolumeSnowParticles( flCurrentTime, flRadius, flZoomScale ); } // Inside of a snow volume. else { CreateInsideVolumeSnowParticles( flCurrentTime, flRadius, vecEyePos, vecForward, flZoomScale ); } } //----------------------------------------------------------------------------- // Purpose: // Input : flCurrentTime - // flRadius - // flZoomScale - //----------------------------------------------------------------------------- void CSnowFallManager::CreateOutsideVolumeSnowParticles( float flCurrentTime, float flRadius, float flZoomScale ) { Vector vecParticleSpawn; // Outside of a snow volume. int iSnow = 0; float flRadiusScaled = flRadius * flZoomScale; float flRadius2 = flRadiusScaled * flRadiusScaled; // Add as many particles as we need while ( m_tSnowFallParticleTimer.NextEvent( flCurrentTime ) ) { // Check for a max particle count. if ( m_pSnowFallEmitter->GetParticleCount() >= r_SnowParticles.GetInt() ) continue; vecParticleSpawn.x = RandomFloat( m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.x, m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.x ); vecParticleSpawn.y = RandomFloat( m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.y, m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.y ); vecParticleSpawn.z = RandomFloat( m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.z, m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.z ); float flDistance2 = ( m_vecSnowFallEmitOrigin - vecParticleSpawn ).LengthSqr(); if ( flDistance2 < flRadius2 ) { CreateSnowFallParticle( vecParticleSpawn, m_aActiveSnow[iSnow] ); } iSnow = ( iSnow + 1 ) % m_nActiveSnowCount; } } //----------------------------------------------------------------------------- // Purpose: // Input : flCurrentTime - // flRadius - // &vecEyePos - // &vecForward - // flZoomScale - //----------------------------------------------------------------------------- void CSnowFallManager::CreateInsideVolumeSnowParticles( float flCurrentTime, float flRadius, const Vector &vecEyePos, const Vector &vecForward, float flZoomScale ) { Vector vecParticleSpawn; // Check/Setup for zoom. bool bZoomed = ( flZoomScale > 1.0f ); float flZoomRadius = 0.0f; Vector vecZoomEmitOrigin; if ( bZoomed ) { vecZoomEmitOrigin = m_vecSnowFallEmitOrigin + ( vecForward * ( r_SnowZoomOffset.GetFloat() * flZoomScale ) ); flZoomRadius = flRadius * flZoomScale; } int iIndex = 0; // Add as many particles as we need while ( m_tSnowFallParticleTimer.NextEvent( flCurrentTime ) ) { // Check for a max particle count. if ( m_pSnowFallEmitter->GetParticleCount() >= r_SnowParticles.GetInt() ) continue; // Create particle inside of sphere. if ( iIndex > 0 ) { CreateSnowParticlesSphere( flZoomRadius ); CreateSnowParticlesRay( flZoomRadius, vecEyePos, vecForward ); } else { CreateSnowParticlesSphere( flRadius ); CreateSnowParticlesRay( flRadius, vecEyePos, vecForward ); } // Increment if zoomed. if ( bZoomed ) { iIndex = ( iIndex + 1 ) % 3; } } } //----------------------------------------------------------------------------- // Purpose: // Input : flRadius - //----------------------------------------------------------------------------- void CSnowFallManager::CreateSnowParticlesSphere( float flRadius ) { Vector vecParticleSpawn; vecParticleSpawn.x = m_vecSnowFallEmitOrigin.x + RandomFloat( -flRadius, flRadius ); vecParticleSpawn.y = m_vecSnowFallEmitOrigin.y + RandomFloat( -flRadius, flRadius ); vecParticleSpawn.z = m_vecSnowFallEmitOrigin.z + RandomFloat( -flRadius, flRadius ); int iSnow = 0; for ( iSnow = 0; iSnow < m_nActiveSnowCount; ++iSnow ) { if ( ( vecParticleSpawn.x < m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.x ) || ( vecParticleSpawn.x > m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.x ) ) continue; if ( ( vecParticleSpawn.y < m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.y ) || ( vecParticleSpawn.y > m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.y ) ) continue; if ( ( vecParticleSpawn.z < m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.z ) || ( vecParticleSpawn.z > m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.z ) ) continue; break; } if ( iSnow == m_nActiveSnowCount ) return; CreateSnowFallParticle( vecParticleSpawn, m_aActiveSnow[iSnow] ); } //----------------------------------------------------------------------------- // Purpose: // Input : &vecEyePos - // &vecForward - //----------------------------------------------------------------------------- void CSnowFallManager::CreateSnowParticlesRay( float flRadius, const Vector &vecEyePos, const Vector &vecForward ) { // Check to see if we should create particles along line-of-sight. if ( !m_bRayParticles && r_SnowRayEnable.GetBool() ) return; Vector vecParticleSpawn; // Create a particle down the player's view beyond the radius. float flRayRadius = r_SnowRayRadius.GetFloat(); Vector vecNewForward; vecNewForward = vecForward * RandomFloat( flRadius, r_SnowRayLength.GetFloat() ); vecParticleSpawn.x = vecEyePos.x + vecNewForward.x; vecParticleSpawn.y = vecEyePos.y + vecNewForward.y; vecParticleSpawn.z = vecEyePos.z + RandomFloat( 72, flRayRadius ); vecParticleSpawn.x += RandomFloat( -flRayRadius, flRayRadius ); vecParticleSpawn.y += RandomFloat( -flRayRadius, flRayRadius ); int iSnow = 0; for ( iSnow = 0; iSnow < m_nActiveSnowCount; ++iSnow ) { if ( ( vecParticleSpawn.x < m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.x ) || ( vecParticleSpawn.x > m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.x ) ) continue; if ( ( vecParticleSpawn.y < m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.y ) || ( vecParticleSpawn.y > m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.y ) ) continue; if ( ( vecParticleSpawn.z < m_aSnow[m_aActiveSnow[iSnow]].m_vecMin.z ) || ( vecParticleSpawn.z > m_aSnow[m_aActiveSnow[iSnow]].m_vecMax.z ) ) continue; break; } if ( iSnow == m_nActiveSnowCount ) return; CreateSnowFallParticle( vecParticleSpawn, m_aActiveSnow[iSnow] ); } void CSnowFallManager::CreateSnowFallParticle( const Vector &vecParticleSpawn, int iSnow ) { SimpleParticle *pParticle = ( SimpleParticle* )m_pSnowFallEmitter->AddParticle( sizeof( SimpleParticle ), m_aSnow[iSnow].m_hMaterial, vecParticleSpawn ); if ( pParticle == NULL ) return; pParticle->m_flLifetime = 0.0f; pParticle->m_vecVelocity = Vector( RandomFloat( -5.0f, 5.0f ), RandomFloat( -5.0f, 5.0f ), ( RandomFloat( -25, -35 ) * r_SnowFallSpeed.GetFloat() ) ); pParticle->m_flDieTime = fabs( ( vecParticleSpawn.z - m_aSnow[iSnow].m_vecMin.z ) / ( pParticle->m_vecVelocity.z - 0.1 ) ); // Probably want to put the color in the snow entity. // pParticle->m_uchColor[0] = 150;//color; // pParticle->m_uchColor[1] = 175;//color; // pParticle->m_uchColor[2] = 200;//color; pParticle->m_uchColor[0] = r_SnowColorRed.GetInt(); pParticle->m_uchColor[1] = r_SnowColorGreen.GetInt(); pParticle->m_uchColor[2] = r_SnowColorBlue.GetInt(); pParticle->m_uchStartSize = r_SnowStartSize.GetInt(); pParticle->m_uchEndSize = r_SnowEndSize.GetInt(); // pParticle->m_uchStartAlpha = 255; pParticle->m_uchStartAlpha = r_SnowStartAlpha.GetInt(); pParticle->m_uchEndAlpha = r_SnowEndAlpha.GetInt(); pParticle->m_flRoll = random->RandomInt( 0, 360 ); pParticle->m_flRollDelta = random->RandomFloat( -0.15f, 0.15f ); pParticle->m_iFlags = SIMPLE_PARTICLE_FLAG_WINDBLOWN; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool SnowFallManagerCreate( CClient_Precipitation *pSnowEntity ) { if ( !s_pSnowFallMgr ) { s_pSnowFallMgr = new CSnowFallManager(); s_pSnowFallMgr->CreateEmitter(); s_pSnowFallMgr->InitializeAsClientEntity( NULL, RENDER_GROUP_OTHER ); if ( !s_pSnowFallMgr ) return false; } s_pSnowFallMgr->AddSnowFallEntity( pSnowEntity ); return true; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void SnowFallManagerDestroy( void ) { if ( s_pSnowFallMgr ) { delete s_pSnowFallMgr; s_pSnowFallMgr = NULL; } }