1HEADmaster

1 files changed, 350 insertions, 0 deletions

diff --git a/game/client/c_hairball.cpp b/game/client/c_hairball.cpp
new file mode 100644
index 0000000..a6e4a42
--- /dev/null
+++ b/game/client/c_hairball.cpp
@@ -0,0 +1,350 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "simple_physics.h"
+#include "mathlib/vmatrix.h"
+#include "beamdraw.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class C_Hairball : public C_BaseEntity
+{
+	DECLARE_CLASS( C_Hairball, C_BaseEntity );
+private:
+
+	class CHairballDelegate : public CSimplePhysics::IHelper
+	{
+	public:
+		virtual void	GetNodeForces( CSimplePhysics::CNode *pNodes, int iNode, Vector *pAccel );
+		virtual void	ApplyConstraints( CSimplePhysics::CNode *pNodes, int nNodes );
+	
+		C_Hairball		*m_pParent;
+	};
+
+
+public:
+	
+						C_Hairball();
+
+	void				Init();
+
+
+// IClientThinkable.
+public:
+	
+	virtual void		ClientThink();
+
+
+// IClientRenderable.
+public:
+
+	virtual int			DrawModel( int flags );
+
+
+
+public:
+
+	float								m_flSphereRadius;
+
+	int									m_nHairs;
+	int									m_nNodesPerHair;
+	float								m_flSpringDist;				// = hair length / (m_nNodesPerHair-1)
+
+	CUtlVector<CSimplePhysics::CNode>	m_Nodes;					// This is m_nHairs * m_nNodesPerHair large.
+	CUtlVector<Vector>					m_HairPositions;			// Untransformed base hair positions, distributed on the sphere.
+	CUtlVector<Vector>					m_TransformedHairPositions;	// Transformed base hair positions, distributed on the sphere.
+
+	CHairballDelegate					m_Delegate;
+	CSimplePhysics						m_Physics;
+
+	IMaterial							*m_pMaterial;
+
+
+	// Super sophisticated AI.
+	float m_flSitStillTime;
+	Vector m_vMoveDir;
+
+	float	m_flSpinDuration;
+	float	m_flCurSpinTime;
+	float	m_flSpinRateX, m_flSpinRateY;
+	
+	bool	m_bFirstThink;
+};
+
+
+void C_Hairball::CHairballDelegate::GetNodeForces( CSimplePhysics::CNode *pNodes, int iNode, Vector *pAccel )
+{
+	pAccel->Init( 0, 0, -1500 );
+}
+
+
+void C_Hairball::CHairballDelegate::ApplyConstraints( CSimplePhysics::CNode *pNodes, int nNodes )
+{
+	int nSegments = m_pParent->m_nNodesPerHair - 1;
+	float flSpringDistSqr = m_pParent->m_flSpringDist * m_pParent->m_flSpringDist;
+
+	static int nIterations = 1;
+	for( int iIteration=0; iIteration < nIterations; iIteration++ )
+	{
+		for ( int iHair=0; iHair < m_pParent->m_nHairs; iHair++ )
+		{
+			CSimplePhysics::CNode *pBase = &pNodes[iHair * m_pParent->m_nNodesPerHair];
+
+			for( int i=0; i < nSegments; i++ )
+			{
+				Vector &vNode1 = pBase[i].m_vPos;
+				Vector &vNode2 = pBase[i+1].m_vPos;
+				Vector vTo = vNode1 - vNode2;
+
+				float flDistSqr = vTo.LengthSqr();
+				if( flDistSqr > flSpringDistSqr )
+				{
+					float flDist = (float)sqrt( flDistSqr );
+					vTo *= 1 - (m_pParent->m_flSpringDist / flDist);
+
+					vNode1 -= vTo * 0.5f;
+					vNode2 += vTo * 0.5f;
+				}
+			}
+
+			// Lock the base of each hair to the right spot.
+			pBase->m_vPos = m_pParent->m_TransformedHairPositions[iHair];
+		}
+	}
+}
+
+
+C_Hairball::C_Hairball()
+{
+	m_nHairs = 100;
+	m_nNodesPerHair = 3;
+	
+	float flHairLength = 20;
+	m_flSpringDist = flHairLength / (m_nNodesPerHair - 1);
+	
+	m_Nodes.SetSize( m_nHairs * m_nNodesPerHair );
+	m_HairPositions.SetSize( m_nHairs );
+	m_TransformedHairPositions.SetSize( m_nHairs );
+
+	m_flSphereRadius = 20;
+	m_vMoveDir.Init();
+	
+	m_flSpinDuration = 1;
+	m_flCurSpinTime = 0;
+	m_flSpinRateX = m_flSpinRateY = 0;
+
+	// Distribute on the sphere (need a better random distribution for the sphere).
+	for ( int i=0; i < m_HairPositions.Count(); i++ )
+	{
+		float theta = RandomFloat( -M_PI, M_PI );
+		float phi   = RandomFloat( -M_PI/2, M_PI/2 );
+		
+		float cosPhi = cos( phi );
+
+		m_HairPositions[i].Init( 
+			cos(theta) * cosPhi * m_flSphereRadius, 
+			sin(theta) * cosPhi * m_flSphereRadius, 
+			sin(phi) * m_flSphereRadius );
+	}
+
+	m_Delegate.m_pParent = this;
+
+	m_Physics.Init( 1.0 / 20 ); // NOTE: PLAY WITH THIS FOR EFFICIENCY
+	m_pMaterial = NULL;
+
+	m_bFirstThink = true;
+}
+
+
+void C_Hairball::Init()
+{
+	ClientEntityList().AddNonNetworkableEntity( this );
+	ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
+	
+	AddToLeafSystem( RENDER_GROUP_OPAQUE_ENTITY );
+
+	m_pMaterial = materials->FindMaterial( "cable/cable", TEXTURE_GROUP_OTHER );
+	m_flSitStillTime = 5;
+}
+
+
+void C_Hairball::ClientThink()
+{
+	// Do some AI-type stuff.. move the entity around.
+	//C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	//m_vecAngles = SetAbsAngles( pPlayer->GetAbsAngles() ); // copy player angles.
+
+	Assert( !GetMoveParent() );
+
+	// Sophisticated AI.
+	m_flCurSpinTime += gpGlobals->frametime;
+	if ( m_flCurSpinTime < m_flSpinDuration )
+	{
+		float div = m_flCurSpinTime / m_flSpinDuration;
+
+		QAngle angles = GetLocalAngles();
+
+		angles.x += m_flSpinRateX * SmoothCurve( div );
+		angles.y += m_flSpinRateY * SmoothCurve( div );
+
+		SetLocalAngles( angles );
+	}
+	else
+	{
+		// Flip between stopped and starting.
+		if ( fabs( m_flSpinRateX ) > 0.01f )
+		{
+			m_flSpinRateX = m_flSpinRateY = 0;
+
+			m_flSpinDuration = RandomFloat( 1, 2 );
+		}
+		else
+		{
+			static float flXSpeed = 3;
+			static float flYSpeed = flXSpeed * 0.1f;
+			m_flSpinRateX = RandomFloat( -M_PI*flXSpeed, M_PI*flXSpeed );
+			m_flSpinRateY = RandomFloat( -M_PI*flYSpeed, M_PI*flYSpeed );
+
+			m_flSpinDuration = RandomFloat( 1, 4 );
+		}
+
+		m_flCurSpinTime = 0;
+	}
+
+	
+	if ( m_flSitStillTime > 0 )
+	{
+		m_flSitStillTime -= gpGlobals->frametime;
+
+		if ( m_flSitStillTime <= 0 )
+		{
+			// Shoot out some random lines and find the longest one.
+			m_vMoveDir.Init( 1, 0, 0 );
+			float flLongestFraction = 0;
+			for ( int i=0; i < 15; i++ )
+			{
+				Vector vDir( RandomFloat( -1, 1 ), RandomFloat( -1, 1 ), RandomFloat( -1, 1 ) );
+				VectorNormalize( vDir );
+
+				trace_t trace;
+				UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vDir * 10000, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &trace );
+
+				if ( trace.fraction != 1.0 )
+				{
+					if ( trace.fraction > flLongestFraction )
+					{
+						flLongestFraction = trace.fraction;
+						m_vMoveDir = vDir;
+					}
+				}
+			}
+
+			m_vMoveDir *= 650; // set speed.
+			m_flSitStillTime = -1; // Move in this direction..
+		}
+	}
+	else
+	{
+		// Move in the specified direction.
+		Vector vEnd = GetAbsOrigin() + m_vMoveDir * gpGlobals->frametime;
+
+		trace_t trace;
+		UTIL_TraceLine( GetAbsOrigin(), vEnd, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &trace );
+
+		if ( trace.fraction < 1 )
+		{
+			// Ok, stop moving.
+			m_flSitStillTime = RandomFloat( 1, 3 );
+		}
+		else
+		{
+			SetLocalOrigin( GetLocalOrigin() + m_vMoveDir * gpGlobals->frametime );
+		}
+	}
+
+	
+	// Transform the base hair positions so we can lock them down.
+	VMatrix mTransform;
+	mTransform.SetupMatrixOrgAngles( GetLocalOrigin(), GetLocalAngles() );
+
+	for ( int i=0; i < m_HairPositions.Count(); i++ )
+	{
+		Vector3DMultiplyPosition( mTransform, m_HairPositions[i], m_TransformedHairPositions[i] );
+	}
+
+	if ( m_bFirstThink )
+	{
+		m_bFirstThink = false;
+		for ( int i=0; i < m_HairPositions.Count(); i++ )
+		{
+			for ( int j=0; j < m_nNodesPerHair; j++ )
+			{
+				m_Nodes[i*m_nNodesPerHair+j].Init( m_TransformedHairPositions[i] );
+			}
+		}
+	}
+
+	// Simulate the physics and apply constraints.
+	m_Physics.Simulate( m_Nodes.Base(), m_Nodes.Count(), &m_Delegate, gpGlobals->frametime, 0.98 );
+}
+
+
+int C_Hairball::DrawModel( int flags )
+{
+	if ( !m_pMaterial )
+		return 0;
+
+	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
+	for ( int iHair=0; iHair < m_nHairs; iHair++ )
+	{
+		CSimplePhysics::CNode *pBase = &m_Nodes[iHair * m_nNodesPerHair];
+		
+		CBeamSegDraw beamDraw;
+		beamDraw.Start( pRenderContext, m_nNodesPerHair-1, m_pMaterial );
+
+		for ( int i=0; i < m_nNodesPerHair; i++ )
+		{
+			BeamSeg_t seg;
+			seg.m_vPos = pBase[i].m_vPredicted;
+			seg.m_vColor.Init( 0, 0, 0 );
+			seg.m_flTexCoord = 0;
+			static float flHairWidth = 1;
+			seg.m_flWidth = flHairWidth;
+			seg.m_flAlpha = 0;
+
+			beamDraw.NextSeg( &seg );
+		}
+		
+		beamDraw.End();
+	}
+
+	return 1;
+}
+
+
+void CreateHairballCallback()
+{
+	for ( int i=0; i < 20; i++ )
+	{
+		C_Hairball *pHairball = new C_Hairball;
+		pHairball->Init();
+		
+		// Put it a short distance in front of the player.
+		C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+		
+		if ( !pPlayer )
+			return;
+
+		Vector vForward;
+		AngleVectors( pPlayer->GetAbsAngles(), &vForward );
+		pHairball->SetLocalOrigin( pPlayer->GetAbsOrigin() + vForward * 300 + RandomVector( 0, 100 ) );
+	}
+}
+
+ConCommand cc_CreateHairball( "CreateHairball", CreateHairballCallback, 0, FCVAR_CHEAT );
+