1

game/client/hl2/c_vehicle_airboat.cpp

@@ -0,0 +1,931 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side implementation of the airboat.
+//
+//			- Dampens motion of driver's view to reduce nausea.
+//			- Autocenters driver's view after a period of inactivity.
+//			- Controls headlights.
+//			- Controls curve parameters for pitch/roll blending.
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_prop_vehicle.h"
+#include "datacache/imdlcache.h"
+#include "flashlighteffect.h"
+#include "movevars_shared.h"
+#include "ammodef.h"
+#include "SpriteTrail.h"
+#include "beamdraw.h"
+#include "enginesprite.h"
+#include "fx_quad.h"
+#include "fx.h"
+#include "fx_water.h"
+#include "engine/ivdebugoverlay.h"
+#include "view.h"
+#include "clienteffectprecachesystem.h"
+#include "c_basehlplayer.h"
+#include "vgui_controls/Controls.h"
+#include "vgui/ISurface.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar r_AirboatViewBlendTo( "r_AirboatViewBlendTo", "1", FCVAR_CHEAT );
+ConVar r_AirboatViewBlendToScale( "r_AirboatViewBlendToScale", "0.03", FCVAR_CHEAT );
+ConVar r_AirboatViewBlendToTime( "r_AirboatViewBlendToTime", "1.5", FCVAR_CHEAT );
+
+ConVar cl_draw_airboat_wake( "cl_draw_airboat_wake", "1", FCVAR_CHEAT );
+
+// Curve parameters for pitch/roll blending.
+// NOTE: Must restart (or create a new airboat) after changing these cvars!
+ConVar r_AirboatRollCurveZero( "r_AirboatRollCurveZero", "90.0", FCVAR_CHEAT );			// Roll less than this is clamped to zero.
+ConVar r_AirboatRollCurveLinear( "r_AirboatRollCurveLinear", "120.0", FCVAR_CHEAT );	// Roll greater than this is mapped directly.
+																						// Spline in between.
+
+ConVar r_AirboatPitchCurveZero( "r_AirboatPitchCurveZero", "25.0", FCVAR_CHEAT );		// Pitch less than this is clamped to zero.
+ConVar r_AirboatPitchCurveLinear( "r_AirboatPitchCurveLinear", "60.0", FCVAR_CHEAT );	// Pitch greater than this is mapped directly.
+																						// Spline in between.
+
+ConVar airboat_joy_response_move( "airboat_joy_response_move", "1" );					// Quadratic steering response
+																						
+
+#define AIRBOAT_DELTA_LENGTH_MAX	12.0f			// 1 foot
+#define AIRBOAT_FRAMETIME_MIN		1e-6
+
+#define HEADLIGHT_DISTANCE		1000
+
+#define	MAX_WAKE_POINTS	16
+#define	WAKE_POINT_MASK (MAX_WAKE_POINTS-1)
+
+#define	WAKE_LIFETIME	0.5f
+
+//=============================================================================
+//
+// Client-side Airboat Class
+//
+class C_PropAirboat : public C_PropVehicleDriveable
+{
+	DECLARE_CLASS( C_PropAirboat, C_PropVehicleDriveable );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+	DECLARE_INTERPOLATION();
+ 	DECLARE_DATADESC();
+
+	C_PropAirboat();
+	~C_PropAirboat();
+
+public:
+
+	// C_BaseEntity
+	virtual void Simulate();
+
+	// IClientVehicle
+	virtual void UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd );
+	virtual void OnEnteredVehicle( C_BasePlayer *pPlayer );
+	virtual int GetPrimaryAmmoType() const;
+	virtual int GetPrimaryAmmoClip() const;
+	virtual bool PrimaryAmmoUsesClips() const;
+	virtual int GetPrimaryAmmoCount() const;
+	virtual int GetJoystickResponseCurve() const;
+
+	int		DrawModel( int flags );
+
+	// Draws crosshair in the forward direction of the boat
+	void DrawHudElements( );
+
+private:
+
+	void DrawPropWake( Vector origin, float speed );
+	void DrawPontoonSplash( Vector position, Vector direction, float speed );
+	void DrawPontoonWake( Vector startPos, Vector wakeDir, float wakeLength, float speed);
+
+	void DampenEyePosition( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles );
+	void DampenForwardMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime );
+	void DampenUpMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime );
+	void ComputePDControllerCoefficients( float *pCoefficientsOut, float flFrequency, float flDampening, float flDeltaTime );
+
+	void UpdateHeadlight( void );
+	void UpdateWake( void );
+	int	 DrawWake( void );
+	void DrawSegment( const BeamSeg_t &beamSeg, const Vector &vNormal );
+
+	TrailPoint_t *GetTrailPoint( int n )
+	{
+		int nIndex = (n + m_nFirstStep) & WAKE_POINT_MASK;
+		return &m_vecSteps[nIndex];
+	}
+
+private:
+
+	Vector		m_vecLastEyePos;
+	Vector		m_vecLastEyeTarget;
+	Vector		m_vecEyeSpeed;
+	Vector		m_vecTargetSpeed;
+
+	float		m_flViewAngleDeltaTime;
+
+	bool		m_bHeadlightIsOn;
+	int			m_nAmmoCount;
+	CHeadlightEffect *m_pHeadlight;
+
+	int				m_nExactWaterLevel;
+	
+	TrailPoint_t	m_vecSteps[MAX_WAKE_POINTS];
+	int				m_nFirstStep;
+	int				m_nStepCount;
+	float			m_flUpdateTime;
+
+	TimedEvent		m_SplashTime;
+	CMeshBuilder	m_Mesh;
+
+	Vector			m_vecPhysVelocity;
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_PropAirboat, DT_PropAirboat, CPropAirboat )
+	RecvPropBool( RECVINFO( m_bHeadlightIsOn ) ),
+	RecvPropInt( RECVINFO( m_nAmmoCount ) ),
+	RecvPropInt( RECVINFO( m_nExactWaterLevel ) ),
+	RecvPropInt( RECVINFO( m_nWaterLevel ) ),
+	RecvPropVector( RECVINFO( m_vecPhysVelocity ) ),
+END_RECV_TABLE()
+
+
+BEGIN_DATADESC( C_PropAirboat )
+	DEFINE_FIELD( m_vecLastEyePos, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecLastEyeTarget, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecEyeSpeed, FIELD_VECTOR ),
+	DEFINE_FIELD( m_vecTargetSpeed, FIELD_VECTOR ),
+	//DEFINE_FIELD( m_flViewAngleDeltaTime, FIELD_FLOAT ),
+END_DATADESC()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+C_PropAirboat::C_PropAirboat()
+{
+	m_vecEyeSpeed.Init();
+	m_flViewAngleDeltaTime = 0.0f;
+	m_pHeadlight = NULL;
+
+	m_ViewSmoothingData.flPitchCurveZero = r_AirboatPitchCurveZero.GetFloat();
+	m_ViewSmoothingData.flPitchCurveLinear = r_AirboatPitchCurveLinear.GetFloat();
+	m_ViewSmoothingData.flRollCurveZero = r_AirboatRollCurveZero.GetFloat();
+	m_ViewSmoothingData.flRollCurveLinear = r_AirboatRollCurveLinear.GetFloat();
+
+	m_ViewSmoothingData.rollLockData.flLockInterval = 1.5;
+	m_ViewSmoothingData.rollLockData.flUnlockBlendInterval = 1.0;
+
+	m_ViewSmoothingData.pitchLockData.flLockInterval = 1.5;
+	m_ViewSmoothingData.pitchLockData.flUnlockBlendInterval = 1.0;
+
+	m_nFirstStep = 0;
+	m_nStepCount = 0;
+	m_SplashTime.Init( 60 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deconstructor
+//-----------------------------------------------------------------------------
+C_PropAirboat::~C_PropAirboat()
+{
+	if (m_pHeadlight)
+	{
+		delete m_pHeadlight;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Draws the ammo for the airboat
+//-----------------------------------------------------------------------------
+int C_PropAirboat::GetPrimaryAmmoType() const
+{
+	if ( m_nAmmoCount < 0 )
+		return -1;
+
+	int nAmmoType = GetAmmoDef()->Index( "AirboatGun" );
+	return nAmmoType; 
+}
+
+int C_PropAirboat::GetPrimaryAmmoCount() const
+{ 
+	return m_nAmmoCount; 
+}
+
+bool C_PropAirboat::PrimaryAmmoUsesClips() const
+{ 
+	return false; 
+}
+
+int C_PropAirboat::GetPrimaryAmmoClip() const
+{ 
+	return -1; 
+}
+
+//-----------------------------------------------------------------------------
+// The airboat prefers a more peppy response curve for joystick control.
+//-----------------------------------------------------------------------------
+int C_PropAirboat::GetJoystickResponseCurve() const
+{
+	return airboat_joy_response_move.GetInt();
+}
+
+//-----------------------------------------------------------------------------
+// Draws crosshair in the forward direction of the boat
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DrawHudElements( )
+{
+	BaseClass::DrawHudElements();
+
+	MDLCACHE_CRITICAL_SECTION();
+
+	CHudTexture *pIcon = gHUD.GetIcon( IsX360() ? "crosshair_default" : "plushair" );
+	if ( pIcon != NULL )
+	{
+		float x, y;
+		Vector screen;
+
+		int vx, vy, vw, vh;
+		vgui::surface()->GetFullscreenViewport( vx, vy, vw, vh );
+		float screenWidth = vw;
+		float screenHeight = vh;
+		
+		x = screenWidth/2;
+		y = screenHeight/2;
+
+		int eyeAttachmentIndex = LookupAttachment( "vehicle_driver_eyes" );
+		Vector vehicleEyeOrigin;
+		QAngle vehicleEyeAngles;
+		GetAttachment( eyeAttachmentIndex, vehicleEyeOrigin, vehicleEyeAngles );
+
+		// Only worry about yaw.
+		vehicleEyeAngles.x = vehicleEyeAngles.z = 0.0f;
+
+		Vector vecForward;
+		AngleVectors( vehicleEyeAngles, &vecForward );
+		VectorMA( vehicleEyeOrigin, 100.0f, vecForward, vehicleEyeOrigin );
+
+		ScreenTransform( vehicleEyeOrigin, screen );
+		x += 0.5 * screen[0] * screenWidth + 0.5;
+		y -= 0.5 * screen[1] * screenHeight + 0.5;
+
+		x -= pIcon->Width() / 2; 
+		y -= pIcon->Height() / 2; 
+		
+		pIcon->DrawSelf( x, y, gHUD.m_clrNormal );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Blend view angles.
+//-----------------------------------------------------------------------------
+void C_PropAirboat::UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd )
+{
+	if ( r_AirboatViewBlendTo.GetInt() )
+	{
+		//
+		// Autocenter the view after a period of no mouse movement while throttling.
+		//
+		bool bResetViewAngleTime = false;
+
+		if ( ( pCmd->mousedx != 0 || pCmd->mousedy != 0 ) || ( fabsf( m_flThrottle ) < 0.01f ) )
+		{
+			if ( IsX360() )
+			{
+				// Only reset this if there isn't an autoaim target!
+				C_BaseHLPlayer *pLocalHLPlayer = (C_BaseHLPlayer *)pLocalPlayer;
+				if ( pLocalHLPlayer )
+				{
+					// Get the autoaim target.
+					CBaseEntity *pTarget = pLocalHLPlayer->m_HL2Local.m_hAutoAimTarget.Get();
+
+					if( !pTarget )
+					{
+						bResetViewAngleTime = true;
+					}
+				}
+			}
+			else
+			{
+				bResetViewAngleTime = true;
+			}
+		}
+
+		if( bResetViewAngleTime )
+		{
+			m_flViewAngleDeltaTime = 0.0f;
+		}
+		else
+		{
+			m_flViewAngleDeltaTime += gpGlobals->frametime;
+		}
+
+		if ( m_flViewAngleDeltaTime > r_AirboatViewBlendToTime.GetFloat() )
+		{
+			// Blend the view angles.
+			int eyeAttachmentIndex = LookupAttachment( "vehicle_driver_eyes" );
+			Vector vehicleEyeOrigin;
+			QAngle vehicleEyeAngles;
+			GetAttachmentLocal( eyeAttachmentIndex, vehicleEyeOrigin, vehicleEyeAngles );
+			
+			QAngle outAngles;
+			InterpolateAngles( pCmd->viewangles, vehicleEyeAngles, outAngles, r_AirboatViewBlendToScale.GetFloat() );
+			pCmd->viewangles = outAngles;
+		}
+	}
+
+	BaseClass::UpdateViewAngles( pLocalPlayer, pCmd );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DampenEyePosition( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles )
+{
+	// Get the frametime. (Check to see if enough time has passed to warrent dampening).
+	float flFrameTime = gpGlobals->frametime;
+	if ( flFrameTime < AIRBOAT_FRAMETIME_MIN )
+	{
+		vecVehicleEyePos = m_vecLastEyePos;
+		DampenUpMotion( vecVehicleEyePos, vecVehicleEyeAngles, 0.0f );
+		return;
+	}
+
+	// Keep static the sideways motion.
+
+	// Dampen forward/backward motion.
+	DampenForwardMotion( vecVehicleEyePos, vecVehicleEyeAngles, flFrameTime );
+
+	// Blend up/down motion.
+	DampenUpMotion( vecVehicleEyePos, vecVehicleEyeAngles, flFrameTime );
+}
+
+
+//-----------------------------------------------------------------------------
+// Use the controller as follows:
+// speed += ( pCoefficientsOut[0] * ( targetPos - currentPos ) + pCoefficientsOut[1] * ( targetSpeed - currentSpeed ) ) * flDeltaTime;
+//-----------------------------------------------------------------------------
+void C_PropAirboat::ComputePDControllerCoefficients( float *pCoefficientsOut,
+												  float flFrequency, float flDampening,
+												  float flDeltaTime )
+{
+	float flKs = 9.0f * flFrequency * flFrequency;
+	float flKd = 4.5f * flFrequency * flDampening;
+
+	float flScale = 1.0f / ( 1.0f + flKd * flDeltaTime + flKs * flDeltaTime * flDeltaTime );
+
+	pCoefficientsOut[0] = flKs * flScale;
+	pCoefficientsOut[1] = ( flKd + flKs * flDeltaTime ) * flScale;
+}
+ 
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DampenForwardMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime )
+{
+	// vecVehicleEyePos = real eye position this frame
+
+	// m_vecLastEyePos = eye position last frame
+	// m_vecEyeSpeed = eye speed last frame
+	// vecPredEyePos = predicted eye position this frame (assuming no acceleration - it will get that from the pd controller).
+	// vecPredEyeSpeed = predicted eye speed
+	Vector vecPredEyePos = m_vecLastEyePos + m_vecEyeSpeed * flFrameTime;
+	Vector vecPredEyeSpeed = m_vecEyeSpeed;
+
+	// m_vecLastEyeTarget = real eye position last frame (used for speed calculation).
+	// Calculate the approximate speed based on the current vehicle eye position and the eye position last frame.
+	Vector vecVehicleEyeSpeed = ( vecVehicleEyePos - m_vecLastEyeTarget ) / flFrameTime;
+	m_vecLastEyeTarget = vecVehicleEyePos;
+	if (vecVehicleEyeSpeed.Length() == 0.0)
+	{
+		return;
+	}
+
+	// Calculate the delta between the predicted eye position and speed and the current eye position and speed.
+	Vector vecDeltaSpeed = vecVehicleEyeSpeed - vecPredEyeSpeed;
+	Vector vecDeltaPos = vecVehicleEyePos - vecPredEyePos;
+
+	// Forward vector.
+	Vector vecForward;
+	AngleVectors( vecVehicleEyeAngles, &vecForward );
+
+	float flDeltaLength = vecDeltaPos.Length();
+	if ( flDeltaLength > AIRBOAT_DELTA_LENGTH_MAX )
+	{
+		// Clamp.
+		float flDelta = flDeltaLength - AIRBOAT_DELTA_LENGTH_MAX;
+		if ( flDelta > 40.0f )
+		{
+			// This part is a bit of a hack to get rid of large deltas (at level load, etc.).
+			m_vecLastEyePos = vecVehicleEyePos;
+			m_vecEyeSpeed = vecVehicleEyeSpeed;
+		}
+		else
+		{
+			// Position clamp.
+			float flRatio = AIRBOAT_DELTA_LENGTH_MAX / flDeltaLength;
+			vecDeltaPos *= flRatio;
+			Vector vecForwardOffset = vecForward * ( vecForward.Dot( vecDeltaPos ) );
+			vecVehicleEyePos -= vecForwardOffset;
+			m_vecLastEyePos = vecVehicleEyePos;
+
+			// Speed clamp.
+			vecDeltaSpeed *= flRatio;
+			float flCoefficients[2];
+			ComputePDControllerCoefficients( flCoefficients, r_AirboatViewDampenFreq.GetFloat(), r_AirboatViewDampenDamp.GetFloat(), flFrameTime );
+			m_vecEyeSpeed += ( ( flCoefficients[0] * vecDeltaPos + flCoefficients[1] * vecDeltaSpeed ) * flFrameTime );
+		}
+	}
+	else
+	{
+		// Generate an updated (dampening) speed for use in next frames position prediction.
+		float flCoefficients[2];
+		ComputePDControllerCoefficients( flCoefficients, r_AirboatViewDampenFreq.GetFloat(), r_AirboatViewDampenDamp.GetFloat(), flFrameTime );
+		m_vecEyeSpeed += ( ( flCoefficients[0] * vecDeltaPos + flCoefficients[1] * vecDeltaSpeed ) * flFrameTime );
+		
+		// Save off data for next frame.
+		m_vecLastEyePos = vecPredEyePos;
+		
+		// Move eye forward/backward.
+		Vector vecForwardOffset = vecForward * ( vecForward.Dot( vecDeltaPos ) );
+		vecVehicleEyePos -= vecForwardOffset;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DampenUpMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime )
+{
+	// Get up vector.
+	Vector vecUp;
+	AngleVectors( vecVehicleEyeAngles, NULL, NULL, &vecUp );
+	vecUp.z = clamp( vecUp.z, 0.0f, vecUp.z );
+	vecVehicleEyePos.z += r_AirboatViewZHeight.GetFloat() * vecUp.z;
+
+	// NOTE: Should probably use some damped equation here.
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PropAirboat::OnEnteredVehicle( C_BasePlayer *pPlayer )
+{
+	int eyeAttachmentIndex = LookupAttachment( "vehicle_driver_eyes" );
+	Vector vehicleEyeOrigin;
+	QAngle vehicleEyeAngles;
+	GetAttachment( eyeAttachmentIndex, vehicleEyeOrigin, vehicleEyeAngles );
+
+	m_vecLastEyeTarget = vehicleEyeOrigin;
+	m_vecLastEyePos = vehicleEyeOrigin;
+	m_vecEyeSpeed = vec3_origin;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PropAirboat::Simulate()
+{
+	UpdateHeadlight();
+	UpdateWake();
+
+	BaseClass::Simulate();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates, destroys, and updates the headlight effect as needed.
+//-----------------------------------------------------------------------------
+void C_PropAirboat::UpdateHeadlight()
+{
+	if (m_bHeadlightIsOn)
+	{
+		if (!m_pHeadlight)
+		{
+			// Turned on the headlight; create it.
+			m_pHeadlight = new CHeadlightEffect();
+
+			if (!m_pHeadlight)
+				return;
+
+			m_pHeadlight->TurnOn();
+		}
+
+		// The headlight is emitted from an attachment point so that it can move
+		// as we turn the handlebars.
+		int nHeadlightIndex = LookupAttachment( "vehicle_headlight" );
+
+		Vector vecLightPos;
+		QAngle angLightDir;
+		GetAttachment(nHeadlightIndex, vecLightPos, angLightDir);
+
+		Vector vecLightDir, vecLightRight, vecLightUp;
+		AngleVectors( angLightDir, &vecLightDir, &vecLightRight, &vecLightUp );
+
+		// Update the light with the new position and direction.		
+		m_pHeadlight->UpdateLight( vecLightPos, vecLightDir, vecLightRight, vecLightUp, HEADLIGHT_DISTANCE );
+	}
+	else if (m_pHeadlight)
+	{
+		// Turned off the headlight; delete it.
+		delete m_pHeadlight;
+		m_pHeadlight = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PropAirboat::UpdateWake( void )
+{
+	if ( gpGlobals->frametime <= 0.0f )
+		return;
+
+	// Can't update too quickly
+	if ( m_flUpdateTime > gpGlobals->curtime )
+		return;
+
+	Vector	screenPos = GetRenderOrigin();
+	screenPos.z = m_nExactWaterLevel;
+
+	TrailPoint_t *pLast = m_nStepCount ? GetTrailPoint( m_nStepCount-1 ) : NULL;
+	if ( ( pLast == NULL ) || ( pLast->m_vecScreenPos.DistToSqr( screenPos ) > 4.0f ) )
+	{
+		// If we're over our limit, steal the last point and put it up front
+		if ( m_nStepCount >= MAX_WAKE_POINTS )
+		{
+			--m_nStepCount;
+			++m_nFirstStep;
+		}
+
+		// Save off its screen position, not its world position
+		TrailPoint_t *pNewPoint = GetTrailPoint( m_nStepCount );
+		pNewPoint->m_vecScreenPos = screenPos + Vector( 0, 0, 2 );
+		pNewPoint->m_flDieTime	= gpGlobals->curtime + WAKE_LIFETIME;
+		pNewPoint->m_flWidthVariance = random->RandomFloat( -16, 16 );
+		
+		if ( pLast )
+		{
+			pNewPoint->m_flTexCoord	= pLast->m_flTexCoord + pLast->m_vecScreenPos.DistTo( screenPos );
+			pNewPoint->m_flTexCoord = fmod( pNewPoint->m_flTexCoord, 1 );
+		}
+		else
+		{
+			pNewPoint->m_flTexCoord = 0.0f;
+		}
+
+		++m_nStepCount;
+	}
+
+	// Don't update again for a bit
+	m_flUpdateTime = gpGlobals->curtime + ( 0.5f / (float) MAX_WAKE_POINTS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &beamSeg - 
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DrawSegment( const BeamSeg_t &beamSeg, const Vector &vNormal )
+{
+	// Build the endpoints.
+	Vector vPoint1, vPoint2;
+	VectorMA( beamSeg.m_vPos,  beamSeg.m_flWidth*0.5f, vNormal, vPoint1 );
+	VectorMA( beamSeg.m_vPos, -beamSeg.m_flWidth*0.5f, vNormal, vPoint2 );
+
+	// Specify the points.
+	m_Mesh.Position3fv( vPoint1.Base() );
+	m_Mesh.Color4f( VectorExpand( beamSeg.m_vColor ), beamSeg.m_flAlpha );
+	m_Mesh.TexCoord2f( 0, 0, beamSeg.m_flTexCoord );
+	m_Mesh.TexCoord2f( 1, 0, beamSeg.m_flTexCoord );
+	m_Mesh.AdvanceVertex();
+
+	m_Mesh.Position3fv( vPoint2.Base() );
+	m_Mesh.Color4f( VectorExpand( beamSeg.m_vColor ), beamSeg.m_flAlpha );
+	m_Mesh.TexCoord2f( 0, 1, beamSeg.m_flTexCoord );
+	m_Mesh.TexCoord2f( 1, 1, beamSeg.m_flTexCoord );
+	m_Mesh.AdvanceVertex();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : position - 
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DrawPontoonSplash( Vector origin, Vector direction, float speed )
+{
+	Vector	offset;
+	
+	CSmartPtr<CSplashParticle> pSimple = CSplashParticle::Create( "splish" );
+	pSimple->SetSortOrigin( origin );
+
+	SimpleParticle	*pParticle;
+
+	Vector	color = Vector( 0.8f, 0.8f, 0.75f );
+	float	colorRamp;
+
+	float	flScale = RemapVal( speed, 64, 256, 0.75f, 1.0f );
+
+	PMaterialHandle	hMaterial;
+	
+	float tempDelta = gpGlobals->frametime;
+
+	while( m_SplashTime.NextEvent( tempDelta ) )
+	{
+		if ( random->RandomInt( 0, 1 ) )
+		{
+			hMaterial = ParticleMgr()->GetPMaterial( "effects/splash1" );
+		}
+		else
+		{
+			hMaterial = ParticleMgr()->GetPMaterial( "effects/splash2" );
+		}
+
+		offset = RandomVector( -8.0f * flScale, 8.0f * flScale );
+		offset[2] = 0.0f;
+		offset += origin;
+
+		pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), hMaterial, offset );
+
+		if ( pParticle == NULL )
+			continue;
+		
+		pParticle->m_flLifetime = 0.0f;
+		pParticle->m_flDieTime	= 0.25f;
+
+		pParticle->m_vecVelocity.Random( -0.4f, 0.4f );
+		pParticle->m_vecVelocity += (direction*5.0f+Vector(0,0,1));
+		
+		VectorNormalize( pParticle->m_vecVelocity );
+
+		pParticle->m_vecVelocity *= speed + random->RandomFloat( -128.0f, 128.0f );
+		
+		colorRamp = random->RandomFloat( 0.75f, 1.25f );
+
+		pParticle->m_uchColor[0]	= MIN( 1.0f, color[0] * colorRamp ) * 255.0f;
+		pParticle->m_uchColor[1]	= MIN( 1.0f, color[1] * colorRamp ) * 255.0f;
+		pParticle->m_uchColor[2]	= MIN( 1.0f, color[2] * colorRamp ) * 255.0f;
+		
+		pParticle->m_uchStartSize	= random->RandomFloat( 8, 16 ) * flScale;
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 2;
+		
+		pParticle->m_uchStartAlpha	= 255;
+		pParticle->m_uchEndAlpha	= 0;
+		
+		pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+		pParticle->m_flRollDelta	= random->RandomFloat( -4.0f, 4.0f );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : Vector	startPos - 
+//			wakeDir - 
+//			wakeLength - 
+//-----------------------------------------------------------------------------
+void C_PropAirboat::DrawPontoonWake( Vector	startPos, Vector wakeDir, float wakeLength, float speed )
+{
+#define	WAKE_STEPS	6
+
+	Vector	wakeStep = wakeDir * ( wakeLength / (float) WAKE_STEPS );
+	Vector	origin;
+	float	scale;
+
+	IMaterial *pMaterial = materials->FindMaterial( "effects/splashwake1", NULL, false );
+	CMatRenderContextPtr pRenderContext( materials );
+	IMesh* pMesh = pRenderContext->GetDynamicMesh( 0, 0, 0, pMaterial );
+
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, WAKE_STEPS );
+
+	for ( int i = 0; i < WAKE_STEPS; i++ )
+	{
+		origin = startPos + ( wakeStep * i );
+		origin[0] += random->RandomFloat( -4.0f, 4.0f );
+		origin[1] += random->RandomFloat( -4.0f, 4.0f );
+		origin[2] = m_nExactWaterLevel + 2.0f;
+
+		float scaleRange = RemapVal( i, 0, WAKE_STEPS-1, 32, 64 );
+		scale = scaleRange + ( 8.0f * sin( gpGlobals->curtime * 5 * i ) );
+		
+		float alpha = RemapValClamped( speed, 128, 600, 0.05f, 0.25f );
+		float color[4] = { 1.0f, 1.0f, 1.0f, alpha };
+		
+		// Needs to be time based so it'll freeze when the game is frozen
+		float yaw = random->RandomFloat( 0, 360 );
+
+		Vector rRight = ( Vector(1,0,0) * cos( DEG2RAD( yaw ) ) ) - ( Vector(0,1,0) * sin( DEG2RAD( yaw ) ) );
+		Vector rUp = ( Vector(1,0,0) * cos( DEG2RAD( yaw+90.0f ) ) ) - ( Vector(0,1,0) * sin( DEG2RAD( yaw+90.0f ) ) );
+
+		Vector point;
+		meshBuilder.Color4fv (color);
+		meshBuilder.TexCoord2f (0, 0, 1);
+		VectorMA (origin, -scale, rRight, point);
+		VectorMA (point, -scale, rUp, point);
+		meshBuilder.Position3fv (point.Base());
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color4fv (color);
+		meshBuilder.TexCoord2f (0, 0, 0);
+		VectorMA (origin, scale, rRight, point);
+		VectorMA (point, -scale, rUp, point);
+		meshBuilder.Position3fv (point.Base());
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color4fv (color);
+		meshBuilder.TexCoord2f (0, 1, 0);
+		VectorMA (origin, scale, rRight, point);
+		VectorMA (point, scale, rUp, point);
+		meshBuilder.Position3fv (point.Base());
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color4fv (color);
+		meshBuilder.TexCoord2f (0, 1, 1);
+		VectorMA (origin, -scale, rRight, point);
+		VectorMA (point, scale, rUp, point);
+		meshBuilder.Position3fv (point.Base());
+		meshBuilder.AdvanceVertex();
+	}
+
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_PropAirboat::DrawWake( void )
+{
+	if ( cl_draw_airboat_wake.GetBool() == false )
+		return 0;
+
+	// Make sure we're in water...
+	if ( GetWaterLevel() == 0 )
+		return 0;
+
+	//FIXME: For now, we don't draw slime this way
+	if ( GetWaterLevel() == 2 )
+		return 0;
+
+	bool bDriven = ( GetPassenger( VEHICLE_ROLE_DRIVER ) != NULL );
+
+	Vector vehicleDir = m_vecPhysVelocity;
+	float vehicleSpeed = VectorNormalize( vehicleDir );
+
+	Vector vecPontoonFrontLeft;
+	Vector vecPontoonFrontRight;
+	Vector vecPontoonRearLeft;
+	Vector vecPontoonRearRight;
+	Vector vecSplashPoint;
+
+	QAngle fooAngles;
+
+	//FIXME: This lookup should be cached off
+	// Get all attachments
+	GetAttachment( LookupAttachment( "raytrace_fl" ), vecPontoonFrontLeft, fooAngles );
+	GetAttachment( LookupAttachment( "raytrace_fr" ), vecPontoonFrontRight, fooAngles );
+	GetAttachment( LookupAttachment( "raytrace_rl" ), vecPontoonRearLeft, fooAngles );
+	GetAttachment( LookupAttachment( "raytrace_rr" ), vecPontoonRearRight, fooAngles );
+	GetAttachment( LookupAttachment( "splash_pt" ), vecSplashPoint, fooAngles );
+
+	// Find the direction of the pontoons
+	Vector vecLeftWakeDir = ( vecPontoonRearLeft - vecPontoonFrontLeft );
+	Vector vecRightWakeDir = ( vecPontoonRearRight - vecPontoonFrontRight );
+
+	// Find the pontoon's size
+	float flWakeLeftLength = VectorNormalize( vecLeftWakeDir );
+	float flWakeRightLength = VectorNormalize( vecRightWakeDir );
+
+	vecPontoonFrontLeft.z = m_nExactWaterLevel;
+	vecPontoonFrontRight.z = m_nExactWaterLevel;
+
+	if ( bDriven && vehicleSpeed > 128.0f )
+	{
+		DrawPontoonWake( vecPontoonFrontLeft, vecLeftWakeDir, flWakeLeftLength, vehicleSpeed );
+		DrawPontoonWake( vecPontoonFrontRight, vecRightWakeDir, flWakeRightLength, vehicleSpeed );
+
+		Vector vecSplashDir;
+		Vector vForward;
+		GetVectors( &vForward, NULL, NULL );
+
+		if ( m_vecPhysVelocity.x < -64.0f )
+		{
+			vecSplashDir = vecLeftWakeDir - vForward;
+			VectorNormalize( vecSplashDir );
+
+			// Don't do this if we're going backwards
+			if ( m_vecPhysVelocity.y > 0.0f )
+			{
+				DrawPontoonSplash( vecPontoonFrontLeft + ( vecLeftWakeDir * 1.0f ), vecSplashDir, m_vecPhysVelocity.y );
+			}
+		}
+		else if ( m_vecPhysVelocity.x > 64.0f )
+		{
+			vecSplashDir = vecRightWakeDir + vForward;
+			VectorNormalize( vecSplashDir );
+
+			// Don't do this if we're going backwards
+			if ( m_vecPhysVelocity.y > 0.0f )
+			{
+				DrawPontoonSplash( vecPontoonFrontRight + ( vecRightWakeDir * 1.0f ), vecSplashDir, m_vecPhysVelocity.y );
+			}
+		}
+	}
+
+	// Must have at least one point
+	if ( m_nStepCount <= 1 )
+		return 1;
+
+	IMaterial *pMaterial = materials->FindMaterial( "effects/splashwake4", 0);
+		
+	//Bind the material
+	CMatRenderContextPtr pRenderContext( materials );
+	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
+	
+	m_Mesh.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, (m_nStepCount-1) * 2 );
+
+	TrailPoint_t *pLast = GetTrailPoint( m_nStepCount - 1 );
+	
+	TrailPoint_t currentPoint;
+	currentPoint.m_flDieTime = gpGlobals->curtime + 0.5f;
+	currentPoint.m_vecScreenPos = GetAbsOrigin();
+	currentPoint.m_vecScreenPos[2] = m_nExactWaterLevel + 16;
+	currentPoint.m_flTexCoord = pLast->m_flTexCoord + currentPoint.m_vecScreenPos.DistTo(pLast->m_vecScreenPos);
+	currentPoint.m_flTexCoord = fmod( currentPoint.m_flTexCoord, 1 );
+	currentPoint.m_flWidthVariance = 0.0f;
+
+	TrailPoint_t *pPrevPoint = NULL;
+	
+	Vector segDir, normal;
+
+	for ( int i = 0; i <= m_nStepCount; ++i )
+	{
+		// This makes it so that we're always drawing to the current location
+		TrailPoint_t *pPoint = (i != m_nStepCount) ? GetTrailPoint(i) : &currentPoint;
+
+		float flLifePerc = RemapValClamped( ( pPoint->m_flDieTime - gpGlobals->curtime ), 0, WAKE_LIFETIME, 0.0f, 1.0f );
+
+		BeamSeg_t curSeg;
+		curSeg.m_vColor.x = curSeg.m_vColor.y = curSeg.m_vColor.z = 1.0f;
+
+		float flAlphaFade = flLifePerc;
+		float alpha = RemapValClamped( fabs( m_vecPhysVelocity.y ), 128, 600, 0.0f, 1.0f );
+
+		curSeg.m_flAlpha = 0.25f;
+		curSeg.m_flAlpha *= flAlphaFade * alpha;
+
+		curSeg.m_vPos = pPoint->m_vecScreenPos;
+		
+		float widthBase = SimpleSplineRemapVal( fabs( m_vecPhysVelocity.y ), 128, 600, 32, 48 );
+
+		curSeg.m_flWidth = Lerp( flLifePerc, widthBase*6, widthBase );
+		curSeg.m_flWidth += pPoint->m_flWidthVariance;
+
+		if ( curSeg.m_flWidth < 0.0f )
+		{
+			curSeg.m_flWidth = 0.0f;
+		}
+
+		curSeg.m_flTexCoord = pPoint->m_flTexCoord;
+
+		if ( pPrevPoint != NULL )
+		{
+			segDir = ( pPrevPoint->m_vecScreenPos - pPoint->m_vecScreenPos );
+			VectorNormalize( segDir );
+
+			normal = CrossProduct( segDir, Vector( 0, 0, -1 ) );
+
+			DrawSegment( curSeg, normal );
+		}
+
+		pPrevPoint = pPoint;
+	}
+
+	m_Mesh.End();
+	pMesh->Draw();
+
+	return 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : flags - 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_PropAirboat::DrawModel( int flags )
+{
+	if ( BaseClass::DrawModel( flags ) == false )
+		return 0;
+	
+	if ( !m_bReadyToDraw )
+		return 0;
+
+	return DrawWake();
+}