First version of the SOurce SDK 2013

1 files changed, 345 insertions, 0 deletions

diff --git a/mp/src/public/vphysics/constraints.h b/mp/src/public/vphysics/constraints.h
new file mode 100644
index 00000000..a9d0b7f4
--- /dev/null
+++ b/mp/src/public/vphysics/constraints.h
@@ -0,0 +1,345 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#ifndef CONSTRAINTS_H

+#define CONSTRAINTS_H

+#ifdef _WIN32

+#pragma once

+#endif

+

+#include "vphysics_interface.h"

+#include "mathlib/mathlib.h"

+

+// constraint groups

+struct constraint_groupparams_t

+{

+	int		additionalIterations;		// additional solver iterations make the constraint system more stable

+	int		minErrorTicks;				// minimum number of ticks with an error before it's reported

+	float	errorTolerance;				// error tolerance in HL units

+

+	inline void Defaults()

+	{

+		additionalIterations = 0;

+		minErrorTicks = 15;

+		errorTolerance = 3.0f;

+	}

+};

+

+// Breakable constraints;

+// 

+//	forceLimit	- kg * in / s limit (N * conversion(in/m))

+//	torqueLimit - kg * in^2 / s (Nm * conversion(in^2/m^2))

+

+// 

+// strength 0 - 1

+struct constraint_breakableparams_t

+{

+	float		strength;				// strength of the constraint 0.0 - 1.0

+	float		forceLimit;				// constraint force limit to break (0 means never break)

+	float		torqueLimit;			// constraint torque limit to break (0 means never break)

+	float		bodyMassScale[2];		// scale applied to mass of reference/attached object before solving constriant

+	bool		isActive;

+

+	inline void Defaults()

+	{

+		forceLimit = 0.0f;

+		torqueLimit = 0.0f;

+		strength = 1.0f;

+		bodyMassScale[0] = 1.0f;

+		bodyMassScale[1] = 1.0f;

+		isActive = true;

+	}

+};

+

+//-----------------------------------------------------------------------------

+// Purpose: constraint limit on a single rotation axis

+//-----------------------------------------------------------------------------

+struct constraint_axislimit_t

+{

+	float		minRotation;

+	float		maxRotation;

+	float		angularVelocity;		// desired angular velocity around hinge

+	float		torque;					// torque to achieve angular velocity (use 0, torque for "friction")

+

+	inline void SetAxisFriction( float rmin, float rmax, float friction )

+	{

+		minRotation = rmin;

+		maxRotation = rmax;

+		angularVelocity = 0;

+		torque = friction;

+	}

+	inline void Defaults()

+	{

+		SetAxisFriction(0,0,0);

+	}

+};

+

+// Builds a transform which maps points in the input object's local space 

+// to the output object's local space

+inline void BuildObjectRelativeXform( IPhysicsObject *pOutputSpace, IPhysicsObject *pInputSpace, matrix3x4_t &xformInToOut )

+{

+	matrix3x4_t outInv, tmp, input;

+	pOutputSpace->GetPositionMatrix( &tmp );

+	MatrixInvert( tmp, outInv );

+	pInputSpace->GetPositionMatrix( &input );

+	ConcatTransforms( outInv, input, xformInToOut );

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: special limited ballsocket constraint for ragdolls.

+//			Has axis limits for all 3 axes.

+//-----------------------------------------------------------------------------

+struct constraint_ragdollparams_t

+{

+	constraint_breakableparams_t constraint;

+	matrix3x4_t			constraintToReference;// xform constraint space to refobject space

+	matrix3x4_t			constraintToAttached;	// xform constraint space to attached object space

+	int					parentIndex;				// NOTE: only used for parsing.  NEED NOT BE SET for create

+	int					childIndex;					// NOTE: only used for parsing.  NEED NOT BE SET for create

+	

+	constraint_axislimit_t	axes[3];

+	bool				onlyAngularLimits;			// only angular limits (not translation as well?)

+	bool				isActive;

+	bool				useClockwiseRotations;		// HACKHACK: Did this wrong in version one.  Fix in the future.

+

+	inline void Defaults()

+	{

+		constraint.Defaults();

+		isActive = true;

+		SetIdentityMatrix( constraintToReference );

+		SetIdentityMatrix( constraintToAttached );

+		parentIndex = -1;

+		childIndex = -1;

+		axes[0].Defaults();

+		axes[1].Defaults();

+		axes[2].Defaults();

+		onlyAngularLimits = false;

+		useClockwiseRotations = false;

+	}

+};

+

+//-----------------------------------------------------------------------------

+// Purpose: Used to init a hinge restricting the relative position and orientation

+//			of two objects to rotation around a single axis

+//-----------------------------------------------------------------------------

+struct constraint_hingeparams_t

+{

+	Vector							worldPosition;			// position in world space on the hinge axis

+	Vector							worldAxisDirection;		// unit direction vector of the hinge axis in world space

+	constraint_axislimit_t			hingeAxis;

+	constraint_breakableparams_t	constraint;

+

+	inline void Defaults()

+	{

+		worldPosition.Init();

+		worldAxisDirection.Init();

+		hingeAxis.Defaults();

+		constraint.Defaults();

+	}

+};

+

+struct constraint_limitedhingeparams_t : public constraint_hingeparams_t

+{

+	Vector							referencePerpAxisDirection;		// unit direction vector vector perpendicular to the hinge axis in world space

+	Vector							attachedPerpAxisDirection;		// unit direction vector vector perpendicular to the hinge axis in world space

+

+	constraint_limitedhingeparams_t() {}

+	constraint_limitedhingeparams_t( const constraint_hingeparams_t &hinge )

+	{

+		static_cast<constraint_hingeparams_t &>(*this) = hinge;

+		referencePerpAxisDirection.Init();

+		attachedPerpAxisDirection.Init();

+	}

+

+	inline void Defaults()

+	{

+		this->constraint_hingeparams_t::Defaults();

+		referencePerpAxisDirection.Init();

+		attachedPerpAxisDirection.Init();

+	}

+};

+

+//-----------------------------------------------------------------------------

+// Purpose: Used to init a constraint that fixes the position and orientation

+//			of two objects relative to each other (like glue)

+//-----------------------------------------------------------------------------

+struct constraint_fixedparams_t

+{

+	matrix3x4_t						attachedRefXform;	// xform attached object space to ref object space

+	constraint_breakableparams_t	constraint;

+	

+	inline void InitWithCurrentObjectState( IPhysicsObject *pRef, IPhysicsObject *pAttached )

+	{

+		BuildObjectRelativeXform( pRef, pAttached, attachedRefXform );

+	}

+

+	inline void Defaults()

+	{

+		SetIdentityMatrix( attachedRefXform );

+		constraint.Defaults();

+	}

+};

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Same parameters as fixed constraint, but torqueLimit has no effect

+//-----------------------------------------------------------------------------

+struct constraint_ballsocketparams_t

+{

+	Vector							constraintPosition[2];		// position of the constraint in each object's space 

+	constraint_breakableparams_t	constraint;

+	inline void Defaults()

+	{

+		constraint.Defaults();

+		constraintPosition[0].Init();

+		constraintPosition[1].Init();

+	}

+

+	void InitWithCurrentObjectState( IPhysicsObject *pRef, IPhysicsObject *pAttached, const Vector &ballsocketOrigin )

+	{

+		pRef->WorldToLocal( &constraintPosition[0], ballsocketOrigin );

+		pAttached->WorldToLocal( &constraintPosition[1], ballsocketOrigin );

+	}

+};

+

+struct constraint_slidingparams_t

+{

+	matrix3x4_t						attachedRefXform;	// xform attached object space to ref object space

+	Vector							slideAxisRef;				// unit direction vector of the slide axis in ref object space

+	constraint_breakableparams_t	constraint;

+	// NOTE: if limitMin == limitMax there is NO limit set!

+	float							limitMin;				// minimum limit coordinate refAxisDirection space

+	float							limitMax;				// maximum limit coordinate refAxisDirection space

+	float							friction;				// friction on sliding

+	float							velocity;				// desired velocity

+

+	inline void Defaults()

+	{

+		SetIdentityMatrix( attachedRefXform );

+		slideAxisRef.Init();

+		limitMin = limitMax = 0;

+		friction = 0;

+		velocity = 0;

+		constraint.Defaults();

+	}

+

+	inline void SetFriction( float inputFriction )

+	{

+		friction = inputFriction;

+		velocity = 0;

+	}

+

+	inline void SetLinearMotor( float inputVelocity, float maxForce )

+	{

+		friction = maxForce;

+		velocity = inputVelocity;

+	}

+

+	inline void InitWithCurrentObjectState( IPhysicsObject *pRef, IPhysicsObject *pAttached, const Vector &slideDirWorldspace )

+	{

+		BuildObjectRelativeXform( pRef, pAttached, attachedRefXform );

+		matrix3x4_t tmp;

+		pRef->GetPositionMatrix( &tmp );

+		VectorIRotate( slideDirWorldspace, tmp, slideAxisRef );

+	}

+};

+

+struct constraint_pulleyparams_t

+{

+	constraint_breakableparams_t	constraint;

+	Vector	pulleyPosition[2];		// These are the pulley positions for the reference and attached objects in world space

+	Vector	objectPosition[2];		// local positions of attachments to the ref,att objects

+	float	totalLength;			// total rope length (include gearing!)

+	float	gearRatio;				// gearing affects attached object ALWAYS

+	bool	isRigid;

+

+	inline void Defaults()

+	{

+		constraint.Defaults();

+		totalLength = 1.0;

+		gearRatio = 1.0;

+		pulleyPosition[0].Init();

+		pulleyPosition[1].Init();

+		objectPosition[0].Init();

+		objectPosition[1].Init();

+		isRigid = false;

+	}

+};

+

+

+struct constraint_lengthparams_t

+{

+	constraint_breakableparams_t	constraint;

+	Vector	objectPosition[2];		// These are the positions for the reference and attached objects in local space

+	float	totalLength;		// Length of rope/spring/constraint.  Distance to maintain

+	float	minLength;			// if rigid, objects are not allowed to move closer than totalLength either

+

+	void InitWorldspace( IPhysicsObject *pRef, IPhysicsObject *pAttached, const Vector &refPosition, const Vector &attachedPosition, bool rigid = false )

+	{

+		pRef->WorldToLocal( &objectPosition[0], refPosition );

+		pAttached->WorldToLocal( &objectPosition[1], attachedPosition );

+		totalLength = (refPosition - attachedPosition).Length();

+		minLength = rigid ? totalLength : 0;

+	}

+

+	inline void Defaults()

+	{

+		constraint.Defaults();

+		objectPosition[0].Init();

+		objectPosition[1].Init();

+		totalLength = 1;

+		minLength = 0;

+	}

+};

+

+class IPhysicsConstraint

+{

+public:

+	virtual ~IPhysicsConstraint( void ) {}

+	

+	// NOTE: Constraints are active when created.  You can temporarily enable/disable them with these functions

+	virtual void			Activate( void ) = 0;

+	virtual void			Deactivate( void ) = 0;

+

+	// set a pointer to the game object

+	virtual void SetGameData( void *gameData ) = 0;

+

+	// get a pointer to the game object

+	virtual void *GetGameData( void ) const = 0;

+

+	// Get the parent/referenced object

+	virtual IPhysicsObject *GetReferenceObject( void ) const = 0;

+

+	// Get the attached object

+	virtual IPhysicsObject *GetAttachedObject( void ) const = 0;

+

+	virtual void			SetLinearMotor( float speed, float maxLinearImpulse ) = 0;

+	virtual void			SetAngularMotor( float rotSpeed, float maxAngularImpulse ) = 0;

+

+	virtual void			UpdateRagdollTransforms( const matrix3x4_t &constraintToReference, const matrix3x4_t &constraintToAttached ) = 0;

+	virtual bool			GetConstraintTransform( matrix3x4_t *pConstraintToReference, matrix3x4_t *pConstraintToAttached ) const = 0;

+	virtual bool			GetConstraintParams( constraint_breakableparams_t *pParams ) const = 0;

+

+	virtual void			OutputDebugInfo() = 0;

+};

+

+

+class IPhysicsConstraintGroup

+{

+public:

+	virtual ~IPhysicsConstraintGroup( void ) {}

+	virtual void Activate() = 0;

+	virtual bool IsInErrorState() = 0;

+	virtual void ClearErrorState() = 0;

+	virtual void GetErrorParams( constraint_groupparams_t *pParams ) = 0;

+	virtual void SetErrorParams( const constraint_groupparams_t &params ) = 0;

+	virtual void SolvePenetration( IPhysicsObject *pObj0, IPhysicsObject *pObj1 ) = 0;

+};

+

+

+#endif // CONSTRAINTS_H