Classes
class	BalanceConstraint
	BalanceConstraint is a kinematic constraint function designed to be passed into a HierarchicalIK module. More...

class	BallJointConstraint
	BallJointConstraint represents ball joint constraint between a body and the world or between two bodies. More...

class	ConstrainedGroup
	ConstrainedGroup is a group of skeletons that interact each other with constraints. More...

class	ConstraintBase
	Constraint is a base class of concrete constraints classes. More...

struct	ConstraintInfo
	ConstraintInfo. More...

class	ConstraintSolver
	ConstraintSolver manages constraints and computes constraint impulses. More...

class	ContactConstraint
	ContactConstraint represents a contact constraint between two bodies. More...

class	DantzigLCPSolver
	DantzigLCPSolver is a LCP solver that uses ODE's implementation of Dantzig algorithm. More...

class	JointConstraint
	class JointConstraint More...

class	JointCoulombFrictionConstraint
	Joint Coulomb friction constraint. More...

class	JointLimitConstraint
	JointLimitConstraint handles joint position or velocity limits. More...

class	LCPSolver
	LCPSolver. More...

class	PGSLCPSolver
	PGSLCPSolver. More...

struct	PGSOption

class	ServoMotorConstraint
	Servo motor constraint. More...

class	SoftContactConstraint
	SoftContactConstraint represents a contact constraint between two bodies. More...

class	WeldJointConstraint
	WeldJointConstraint represents weld joint constraint between a body and the world or between two bodies. More...

Typedefs
using	ConstrainedGroupPtr = std::shared_ptr< ConstrainedGroup >

using	ConstConstrainedGroupPtr = std::shared_ptr< const ConstrainedGroup >

using	WeakConstrainedGroupPtr = std::weak_ptr< ConstrainedGroup >

using	WeakConstConstrainedGroupPtr = std::weak_ptr< const ConstrainedGroup >

using	ConstraintBasePtr = std::shared_ptr< ConstraintBase >

using	ConstConstraintBasePtr = std::shared_ptr< const ConstraintBase >

using	WeakConstraintBasePtr = std::weak_ptr< ConstraintBase >

using	WeakConstConstraintBasePtr = std::weak_ptr< const ConstraintBase >

using	ClosedLoopConstraintPtr = std::shared_ptr< ClosedLoopConstraint >

using	ConstClosedLoopConstraintPtr = std::shared_ptr< const ClosedLoopConstraint >

using	WeakClosedLoopConstraintPtr = std::weak_ptr< ClosedLoopConstraint >

using	WeakConstClosedLoopConstraintPtr = std::weak_ptr< const ClosedLoopConstraint >

using	ContactConstraintPtr = std::shared_ptr< ContactConstraint >

using	ConstContactConstraintPtr = std::shared_ptr< const ContactConstraint >

using	WeakContactConstraintPtr = std::weak_ptr< ContactConstraint >

using	WeakConstContactConstraintPtr = std::weak_ptr< const ContactConstraint >

using	SoftContactConstraintPtr = std::shared_ptr< SoftContactConstraint >

using	ConstSoftContactConstraintPtr = std::shared_ptr< const SoftContactConstraint >

using	WeakSoftContactConstraintPtr = std::weak_ptr< SoftContactConstraint >

using	WeakConstSoftContactConstraintPtr = std::weak_ptr< const SoftContactConstraint >

using	JointLimitConstraintPtr = std::shared_ptr< JointLimitConstraint >

using	ConstJointLimitConstraintPtr = std::shared_ptr< const JointLimitConstraint >

using	WeakJointLimitConstraintPtr = std::weak_ptr< JointLimitConstraint >

using	WeakConstJointLimitConstraintPtr = std::weak_ptr< const JointLimitConstraint >

using	ServoMotorConstraintPtr = std::shared_ptr< ServoMotorConstraint >

using	ConstServoMotorConstraintPtr = std::shared_ptr< const ServoMotorConstraint >

using	WeakServoMotorConstraintPtr = std::weak_ptr< ServoMotorConstraint >

using	WeakConstServoMotorConstraintPtr = std::weak_ptr< const ServoMotorConstraint >

using	JointCoulombFrictionConstraintPtr = std::shared_ptr< JointCoulombFrictionConstraint >

using	ConstJointCoulombFrictionConstraintPtr = std::shared_ptr< const JointCoulombFrictionConstraint >

using	WeakJointCoulombFrictionConstraintPtr = std::weak_ptr< JointCoulombFrictionConstraint >

using	WeakConstJointCoulombFrictionConstraintPtr = std::weak_ptr< const JointCoulombFrictionConstraint >

using	JointConstraintPtr = std::shared_ptr< JointConstraint >

using	ConstJointConstraintPtr = std::shared_ptr< const JointConstraint >

using	WeakJointConstraintPtr = std::weak_ptr< JointConstraint >

using	WeakConstJointConstraintPtr = std::weak_ptr< const JointConstraint >

using	LCPSolverPtr = std::shared_ptr< LCPSolver >

using	ConstLCPSolverPtr = std::shared_ptr< const LCPSolver >

using	WeakLCPSolverPtr = std::weak_ptr< LCPSolver >

using	WeakConstLCPSolverPtr = std::weak_ptr< const LCPSolver >

using	BallJointConstraintPtr = std::shared_ptr< BallJointConstraint >

using	ConstBallJointConstraintPtr = std::shared_ptr< const BallJointConstraint >

using	WeakBallJointConstraintPtr = std::weak_ptr< BallJointConstraint >

using	WeakConstBallJointConstraintPtr = std::weak_ptr< const BallJointConstraint >

using	WeldJointConstraintPtr = std::shared_ptr< WeldJointConstraint >

using	ConstWeldJointConstraintPtr = std::shared_ptr< const WeldJointConstraint >

using	WeakWeldJointConstraintPtr = std::weak_ptr< WeldJointConstraint >

using	WeakConstWeldJointConstraintPtr = std::weak_ptr< const WeldJointConstraint >

using	BalanceConstraintPtr = std::shared_ptr< BalanceConstraint >

using	ConstBalanceConstraintPtr = std::shared_ptr< const BalanceConstraint >

using	WeakBalanceConstraintPtr = std::weak_ptr< BalanceConstraint >

using	WeakConstBalanceConstraintPtr = std::weak_ptr< const BalanceConstraint >

Functions
template<typename JacType >
static void	addDampedPseudoInverseToGradient (Eigen::Map< Eigen::VectorXd > &grad, const JacType &J, const Eigen::MatrixXd &nullspace, const Eigen::Vector3d &error, double damping)

bool	solvePGS (int n, int nskip, int, double A, double x, double b, double lo, double hi, int findex, PGSOption *option)

template<typename PointMassT , typename SoftBodyNodeT >
static PointMassT	selectCollidingPointMassT (SoftBodyNodeT _softBodyNode, const Eigen::Vector3d &_point, int _faceId)

Typedef Documentation

◆ BalanceConstraintPtr

using dart::constraint::BalanceConstraintPtr = typedef std::shared_ptr< BalanceConstraint >

◆ BallJointConstraintPtr

using dart::constraint::BallJointConstraintPtr = typedef std::shared_ptr< BallJointConstraint >

◆ ClosedLoopConstraintPtr

using dart::constraint::ClosedLoopConstraintPtr = typedef std::shared_ptr< ClosedLoopConstraint >

◆ ConstBalanceConstraintPtr

using dart::constraint::ConstBalanceConstraintPtr = typedef std::shared_ptr<const BalanceConstraint >

◆ ConstBallJointConstraintPtr

using dart::constraint::ConstBallJointConstraintPtr = typedef std::shared_ptr<const BallJointConstraint >

◆ ConstClosedLoopConstraintPtr

using dart::constraint::ConstClosedLoopConstraintPtr = typedef std::shared_ptr<const ClosedLoopConstraint >

◆ ConstConstrainedGroupPtr

using dart::constraint::ConstConstrainedGroupPtr = typedef std::shared_ptr<const ConstrainedGroup >

◆ ConstConstraintBasePtr

using dart::constraint::ConstConstraintBasePtr = typedef std::shared_ptr<const ConstraintBase >

◆ ConstContactConstraintPtr

using dart::constraint::ConstContactConstraintPtr = typedef std::shared_ptr<const ContactConstraint >

◆ ConstJointConstraintPtr

using dart::constraint::ConstJointConstraintPtr = typedef std::shared_ptr<const JointConstraint >

◆ ConstJointCoulombFrictionConstraintPtr

using dart::constraint::ConstJointCoulombFrictionConstraintPtr = typedef std::shared_ptr<const JointCoulombFrictionConstraint >

◆ ConstJointLimitConstraintPtr

using dart::constraint::ConstJointLimitConstraintPtr = typedef std::shared_ptr<const JointLimitConstraint >

◆ ConstLCPSolverPtr

using dart::constraint::ConstLCPSolverPtr = typedef std::shared_ptr<const LCPSolver >

◆ ConstrainedGroupPtr

using dart::constraint::ConstrainedGroupPtr = typedef std::shared_ptr< ConstrainedGroup >

◆ ConstraintBasePtr

using dart::constraint::ConstraintBasePtr = typedef std::shared_ptr< ConstraintBase >

◆ ConstServoMotorConstraintPtr

using dart::constraint::ConstServoMotorConstraintPtr = typedef std::shared_ptr<const ServoMotorConstraint >

◆ ConstSoftContactConstraintPtr

using dart::constraint::ConstSoftContactConstraintPtr = typedef std::shared_ptr<const SoftContactConstraint >

◆ ConstWeldJointConstraintPtr

using dart::constraint::ConstWeldJointConstraintPtr = typedef std::shared_ptr<const WeldJointConstraint >

◆ ContactConstraintPtr

using dart::constraint::ContactConstraintPtr = typedef std::shared_ptr< ContactConstraint >

◆ JointConstraintPtr

using dart::constraint::JointConstraintPtr = typedef std::shared_ptr< JointConstraint >

◆ JointCoulombFrictionConstraintPtr

using dart::constraint::JointCoulombFrictionConstraintPtr = typedef std::shared_ptr< JointCoulombFrictionConstraint >

◆ JointLimitConstraintPtr

using dart::constraint::JointLimitConstraintPtr = typedef std::shared_ptr< JointLimitConstraint >

◆ LCPSolverPtr

using dart::constraint::LCPSolverPtr = typedef std::shared_ptr< LCPSolver >

◆ ServoMotorConstraintPtr

using dart::constraint::ServoMotorConstraintPtr = typedef std::shared_ptr< ServoMotorConstraint >

◆ SoftContactConstraintPtr

using dart::constraint::SoftContactConstraintPtr = typedef std::shared_ptr< SoftContactConstraint >

◆ WeakBalanceConstraintPtr

using dart::constraint::WeakBalanceConstraintPtr = typedef std::weak_ptr< BalanceConstraint >

◆ WeakBallJointConstraintPtr

using dart::constraint::WeakBallJointConstraintPtr = typedef std::weak_ptr< BallJointConstraint >

◆ WeakClosedLoopConstraintPtr

using dart::constraint::WeakClosedLoopConstraintPtr = typedef std::weak_ptr< ClosedLoopConstraint >

◆ WeakConstBalanceConstraintPtr

using dart::constraint::WeakConstBalanceConstraintPtr = typedef std::weak_ptr<const BalanceConstraint >

◆ WeakConstBallJointConstraintPtr

using dart::constraint::WeakConstBallJointConstraintPtr = typedef std::weak_ptr<const BallJointConstraint >

◆ WeakConstClosedLoopConstraintPtr

using dart::constraint::WeakConstClosedLoopConstraintPtr = typedef std::weak_ptr<const ClosedLoopConstraint >

◆ WeakConstConstrainedGroupPtr

using dart::constraint::WeakConstConstrainedGroupPtr = typedef std::weak_ptr<const ConstrainedGroup >

◆ WeakConstConstraintBasePtr

using dart::constraint::WeakConstConstraintBasePtr = typedef std::weak_ptr<const ConstraintBase >

◆ WeakConstContactConstraintPtr

using dart::constraint::WeakConstContactConstraintPtr = typedef std::weak_ptr<const ContactConstraint >

◆ WeakConstJointConstraintPtr

using dart::constraint::WeakConstJointConstraintPtr = typedef std::weak_ptr<const JointConstraint >

◆ WeakConstJointCoulombFrictionConstraintPtr

using dart::constraint::WeakConstJointCoulombFrictionConstraintPtr = typedef std::weak_ptr<const JointCoulombFrictionConstraint >

◆ WeakConstJointLimitConstraintPtr

using dart::constraint::WeakConstJointLimitConstraintPtr = typedef std::weak_ptr<const JointLimitConstraint >

◆ WeakConstLCPSolverPtr

using dart::constraint::WeakConstLCPSolverPtr = typedef std::weak_ptr<const LCPSolver >

◆ WeakConstrainedGroupPtr

using dart::constraint::WeakConstrainedGroupPtr = typedef std::weak_ptr< ConstrainedGroup >

◆ WeakConstraintBasePtr

using dart::constraint::WeakConstraintBasePtr = typedef std::weak_ptr< ConstraintBase >

◆ WeakConstServoMotorConstraintPtr

using dart::constraint::WeakConstServoMotorConstraintPtr = typedef std::weak_ptr<const ServoMotorConstraint >

◆ WeakConstSoftContactConstraintPtr

using dart::constraint::WeakConstSoftContactConstraintPtr = typedef std::weak_ptr<const SoftContactConstraint >

◆ WeakConstWeldJointConstraintPtr

using dart::constraint::WeakConstWeldJointConstraintPtr = typedef std::weak_ptr<const WeldJointConstraint >

◆ WeakContactConstraintPtr

using dart::constraint::WeakContactConstraintPtr = typedef std::weak_ptr< ContactConstraint >

◆ WeakJointConstraintPtr

using dart::constraint::WeakJointConstraintPtr = typedef std::weak_ptr< JointConstraint >

◆ WeakJointCoulombFrictionConstraintPtr

using dart::constraint::WeakJointCoulombFrictionConstraintPtr = typedef std::weak_ptr< JointCoulombFrictionConstraint >

◆ WeakJointLimitConstraintPtr

using dart::constraint::WeakJointLimitConstraintPtr = typedef std::weak_ptr< JointLimitConstraint >

◆ WeakLCPSolverPtr

using dart::constraint::WeakLCPSolverPtr = typedef std::weak_ptr< LCPSolver >

◆ WeakServoMotorConstraintPtr

using dart::constraint::WeakServoMotorConstraintPtr = typedef std::weak_ptr< ServoMotorConstraint >

◆ WeakSoftContactConstraintPtr

using dart::constraint::WeakSoftContactConstraintPtr = typedef std::weak_ptr< SoftContactConstraint >

◆ WeakWeldJointConstraintPtr

using dart::constraint::WeakWeldJointConstraintPtr = typedef std::weak_ptr< WeldJointConstraint >

◆ WeldJointConstraintPtr

using dart::constraint::WeldJointConstraintPtr = typedef std::shared_ptr< WeldJointConstraint >

Function Documentation

◆ addDampedPseudoInverseToGradient()

template<typename JacType >

static void dart::constraint::addDampedPseudoInverseToGradient	(	Eigen::Map< Eigen::VectorXd > &	grad,
		const JacType &	J,
		const Eigen::MatrixXd &	nullspace,
		const Eigen::Vector3d &	error,
		double	damping
	)

static

◆ selectCollidingPointMassT()

template<typename PointMassT , typename SoftBodyNodeT >

static PointMassT dart::constraint::selectCollidingPointMassT	(	SoftBodyNodeT	_softBodyNode,
		const Eigen::Vector3d &	_point,
		int	_faceId
	)