tf2/tf2_src/game/shared/sheetsimulator.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#ifndef SHEETSIMULATOR_H
#define SHEETSIMULATOR_H
#ifdef _WIN32
#pragma once
#endif

#include "mathlib/mathlib.h"
#include "mathlib/vector.h"
#include "utlvector.h"


// Uncomment this for client-side simulation
//#define CLIENT_SIDE_SIMULATION 1

//-----------------------------------------------------------------------------
// Simulates a sheet
//-----------------------------------------------------------------------------

class CGameTrace;
typedef CGameTrace trace_t;
//struct trace_t;
typedef void (*TraceLineFunc_t)(const Vector &vecStart, const Vector &vecEnd, 
								unsigned int mask, int collisionGroup, trace_t *ptr);
typedef void (*TraceHullFunc_t)(const Vector &vecStart, const Vector &vecEnd, 
								const Vector &hullMin, const Vector &hullMax, 
								unsigned int mask, int collisionGroup, trace_t *ptr);


class CSheetSimulator
{
public:
	CSheetSimulator( TraceLineFunc_t traceline, TraceHullFunc_t traceHull );
	~CSheetSimulator();

	void Init( int w, int h, int fixedPointCount );

	// orientation
	void SetPosition( const Vector& origin, const QAngle& angles );

	// Makes a spring
	void AddSpring( int p1, int p2, float restLength );
	void AddFixedPointSpring( int fixedPoint, int p, float restLength );

	// spring constants....
	void SetPointSpringConstant( float constant );
	void SetFixedSpringConstant( float constant );

	// Used for both kinds of springs
	void SetSpringDampConstant( float damp );
	void SetViscousDrag( float drag );

	// Sets the collision group
	void SetCollisionGroup( int group );

	// Sets the bounding box used for collision vs world
	void SetBoundingBox( Vector& mins, Vector& maxs );

	// Computes the bounding box
	void ComputeBounds( Vector& mins, Vector& maxs );

	// simulation
	void Simulate( float dt );
	void Simulate( float dt, int steps );

	// get at the points
	int NumHorizontal() const;
	int NumVertical() const;
	int PointCount() const;

	// Fixed points
	Vector& GetFixedPoint( int i );

	// Point masses
	const Vector& GetPoint( int x, int y ) const;
	const Vector& GetPoint( int i ) const;

	// For iterative collision detection
	void DetectCollision( int i, float flOffset );
	void InitPosition( int i );

	// For offseting the control points
	void SetControlPointOffset( const Vector& offset );

	// Gravity
	void SetGravityConstant( float g );
	void AddGravityForce( int particle );

protected:
	struct Particle_t
	{
		float	m_Mass;
		Vector	m_Position;
		Vector	m_Velocity;
		Vector	m_Force;
		int		m_Collided;
		int		m_CollisionPlane;
		float	m_CollisionDist;
	};

	struct Spring_t
	{
		int m_Particle1;
		int m_Particle2;
		float m_RestLength;
	};

	inline int NumParticles() const
	{
		return m_HorizontalCount * m_VerticalCount; 
	}

	// simulator
	void			EulerStep( float dt );
	void			ComputeControlPoints();
	void			ClearForces();
	void			ComputeForces();
	void			TestVertAgainstPlane( int vert, int plane, bool bFarTest = true );
	void			SatisfyCollisionConstraints();
	void			DetermineBestCollisionPlane( bool bFarTest = true );
	void			ClampPointsToCollisionPlanes();

	// How many particles horiz + vert?
	int m_HorizontalCount;
	int m_VerticalCount;

	// The particles
	Particle_t*	m_Particle;

	// Output position after simulation
	Vector*	m_OutputPosition;

	// fixed points
	int	m_FixedPointCount;
	Vector* m_pFixedPoint;
	Vector* m_ControlPoints;
	
	CUtlVector<Spring_t>	m_Springs;
	CUtlVector<int>			m_Gravity;

	// raycasting methods
	TraceLineFunc_t		m_TraceLine;
	TraceHullFunc_t		m_TraceHull;

	// Spring constants
	float	m_FixedSpringConstant;
	float	m_PointSpringConstant;
	float	m_DampConstant;
	float	m_ViscousDrag;

	// Collision group
	int		m_CollisionGroup;

	// position + orientation
	Vector	m_Origin;
	QAngle	m_Angles;

	// collision box
	Vector  m_FrustumBoxMin;
	Vector	m_FrustumBoxMax;

	// Collision planes
	cplane_t*	m_pCollisionPlanes;
	bool*		m_pValidCollisionPlane;

	// Control point offset
	Vector		m_ControlPointOffset;

	// Gravity
	float		m_GravityConstant;
};


//-----------------------------------------------------------------------------
// Class to help dealing with the iterative computation
//-----------------------------------------------------------------------------

class CIterativeSheetSimulator : public CSheetSimulator
{
public:
	CIterativeSheetSimulator( TraceLineFunc_t traceline, TraceHullFunc_t traceHull );

	void BeginSimulation( float dt, int steps, int substeps, int collisionCount );

	// Returns true if it just did a simulation step
	bool Think( );
	bool IsDone() const { return m_SimulationSteps == 0; }

	int StepsRemaining( ) const { return m_SimulationSteps; }

private:
	CIterativeSheetSimulator( const CIterativeSheetSimulator & ); // not defined, not accessible

	// Iterative collision detection 
	void DetectCollisions( void );

	float	m_TimeStep;
	float	m_SubSteps;
	char	m_TotalSteps;
	char	m_SimulationSteps;
	char	m_CollisionCount;
	char	m_CurrentCollisionPt;
	bool	m_InitialPass;
};


#endif // TF_SHIELD_SHARED_H