source-engine/public/vphysics/constraints.h

346 lines
11 KiB
C
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= 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() = default;
2020-04-22 16:56:21 +00:00
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