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	BoxedLcpConstraintSolver

class	BoxedLcpSolver

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	DantzigBoxedLcpSolver

class	DantzigLCPSolver

class	JointConstraint
	class JointConstraint More...

class	JointCoulombFrictionConstraint
	Joint Coulomb friction constraint. More...

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

class	LCPSolver

class	MimicMotorConstraint
	Servo motor constraint. More...

class	PgsBoxedLcpSolver
	Implementation of projected Gauss-Seidel (PGS) LCP solver. More...

class	PGSLCPSolver

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	ConstraintSolverPtr = std::shared_ptr< ConstraintSolver >

using	ConstConstraintSolverPtr = std::shared_ptr< const ConstraintSolver >

using	WeakConstraintSolverPtr = std::weak_ptr< ConstraintSolver >

using	WeakConstConstraintSolverPtr = std::weak_ptr< const ConstraintSolver >

using	UniqueConstraintSolverPtr = std::unique_ptr< ConstraintSolver >

using	UniqueConstConstraintSolverPtr = std::unique_ptr< const ConstraintSolver >

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	MimicMotorConstraintPtr = std::shared_ptr< MimicMotorConstraint >

using	ConstMimicMotorConstraintPtr = std::shared_ptr< const MimicMotorConstraint >

using	WeakMimicMotorConstraintPtr = std::weak_ptr< MimicMotorConstraint >

using	WeakConstMimicMotorConstraintPtr = std::weak_ptr< const MimicMotorConstraint >

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	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	BoxedLcpSolverPtr = std::shared_ptr< BoxedLcpSolver >

using	ConstBoxedLcpSolverPtr = std::shared_ptr< const BoxedLcpSolver >

using	WeakBoxedLcpSolverPtr = std::weak_ptr< BoxedLcpSolver >

using	WeakConstBoxedLcpSolverPtr = std::weak_ptr< const BoxedLcpSolver >

using	PgsBoxedLcpSolverPtr = std::shared_ptr< PgsBoxedLcpSolver >

using	ConstPgsBoxedLcpSolverPtr = std::shared_ptr< const PgsBoxedLcpSolver >

using	WeakPgsBoxedLcpSolverPtr = std::weak_ptr< PgsBoxedLcpSolver >

using	WeakConstPgsBoxedLcpSolverPtr = std::weak_ptr< const PgsBoxedLcpSolver >

using	PsorBoxedLcpSolverPtr = std::shared_ptr< PsorBoxedLcpSolver >

using	ConstPsorBoxedLcpSolverPtr = std::shared_ptr< const PsorBoxedLcpSolver >

using	WeakPsorBoxedLcpSolverPtr = std::weak_ptr< PsorBoxedLcpSolver >

using	WeakConstPsorBoxedLcpSolverPtr = std::weak_ptr< const PsorBoxedLcpSolver >

using	JacobiBoxedLcpSolverPtr = std::shared_ptr< JacobiBoxedLcpSolver >

using	ConstJacobiBoxedLcpSolverPtr = std::shared_ptr< const JacobiBoxedLcpSolver >

using	WeakJacobiBoxedLcpSolverPtr = std::weak_ptr< JacobiBoxedLcpSolver >

using	WeakConstJacobiBoxedLcpSolverPtr = std::weak_ptr< const JacobiBoxedLcpSolver >

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	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 >

◆ BoxedLcpSolverPtr

using dart::constraint::BoxedLcpSolverPtr = typedef std::shared_ptr< BoxedLcpSolver >

◆ 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 >

◆ ConstBoxedLcpSolverPtr

using dart::constraint::ConstBoxedLcpSolverPtr = typedef std::shared_ptr<const BoxedLcpSolver >

◆ 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 >

◆ ConstConstraintSolverPtr

using dart::constraint::ConstConstraintSolverPtr = typedef std::shared_ptr<const ConstraintSolver >

◆ ConstContactConstraintPtr

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

◆ ConstJacobiBoxedLcpSolverPtr

using dart::constraint::ConstJacobiBoxedLcpSolverPtr = typedef std::shared_ptr<const JacobiBoxedLcpSolver >

◆ 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 >

◆ ConstMimicMotorConstraintPtr

using dart::constraint::ConstMimicMotorConstraintPtr = typedef std::shared_ptr<const MimicMotorConstraint >

◆ ConstPgsBoxedLcpSolverPtr

using dart::constraint::ConstPgsBoxedLcpSolverPtr = typedef std::shared_ptr<const PgsBoxedLcpSolver >

◆ ConstPsorBoxedLcpSolverPtr

using dart::constraint::ConstPsorBoxedLcpSolverPtr = typedef std::shared_ptr<const PsorBoxedLcpSolver >

◆ ConstrainedGroupPtr

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

◆ ConstraintBasePtr

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

◆ ConstraintSolverPtr

using dart::constraint::ConstraintSolverPtr = typedef std::shared_ptr< ConstraintSolver >

◆ 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 >

◆ JacobiBoxedLcpSolverPtr

using dart::constraint::JacobiBoxedLcpSolverPtr = typedef std::shared_ptr< JacobiBoxedLcpSolver >

◆ 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 >

◆ MimicMotorConstraintPtr

using dart::constraint::MimicMotorConstraintPtr = typedef std::shared_ptr< MimicMotorConstraint >

◆ PgsBoxedLcpSolverPtr

using dart::constraint::PgsBoxedLcpSolverPtr = typedef std::shared_ptr< PgsBoxedLcpSolver >

◆ PsorBoxedLcpSolverPtr

using dart::constraint::PsorBoxedLcpSolverPtr = typedef std::shared_ptr< PsorBoxedLcpSolver >

◆ ServoMotorConstraintPtr

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

◆ SoftContactConstraintPtr

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

◆ UniqueConstConstraintSolverPtr

using dart::constraint::UniqueConstConstraintSolverPtr = typedef std::unique_ptr<const ConstraintSolver >

◆ UniqueConstraintSolverPtr

using dart::constraint::UniqueConstraintSolverPtr = typedef std::unique_ptr< ConstraintSolver >

◆ WeakBalanceConstraintPtr

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

◆ WeakBallJointConstraintPtr

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

◆ WeakBoxedLcpSolverPtr

using dart::constraint::WeakBoxedLcpSolverPtr = typedef std::weak_ptr< BoxedLcpSolver >

◆ 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 >

◆ WeakConstBoxedLcpSolverPtr

using dart::constraint::WeakConstBoxedLcpSolverPtr = typedef std::weak_ptr<const BoxedLcpSolver >

◆ 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 >

◆ WeakConstConstraintSolverPtr

using dart::constraint::WeakConstConstraintSolverPtr = typedef std::weak_ptr<const ConstraintSolver >

◆ WeakConstContactConstraintPtr

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

◆ WeakConstJacobiBoxedLcpSolverPtr

using dart::constraint::WeakConstJacobiBoxedLcpSolverPtr = typedef std::weak_ptr<const JacobiBoxedLcpSolver >

◆ 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 >

◆ WeakConstMimicMotorConstraintPtr

using dart::constraint::WeakConstMimicMotorConstraintPtr = typedef std::weak_ptr<const MimicMotorConstraint >

◆ WeakConstPgsBoxedLcpSolverPtr

using dart::constraint::WeakConstPgsBoxedLcpSolverPtr = typedef std::weak_ptr<const PgsBoxedLcpSolver >

◆ WeakConstPsorBoxedLcpSolverPtr

using dart::constraint::WeakConstPsorBoxedLcpSolverPtr = typedef std::weak_ptr<const PsorBoxedLcpSolver >

◆ WeakConstrainedGroupPtr

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

◆ WeakConstraintBasePtr

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

◆ WeakConstraintSolverPtr

using dart::constraint::WeakConstraintSolverPtr = typedef std::weak_ptr< ConstraintSolver >

◆ 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 >

◆ WeakJacobiBoxedLcpSolverPtr

using dart::constraint::WeakJacobiBoxedLcpSolverPtr = typedef std::weak_ptr< JacobiBoxedLcpSolver >

◆ 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 >

◆ WeakMimicMotorConstraintPtr

using dart::constraint::WeakMimicMotorConstraintPtr = typedef std::weak_ptr< MimicMotorConstraint >

◆ WeakPgsBoxedLcpSolverPtr

using dart::constraint::WeakPgsBoxedLcpSolverPtr = typedef std::weak_ptr< PgsBoxedLcpSolver >

◆ WeakPsorBoxedLcpSolverPtr

using dart::constraint::WeakPsorBoxedLcpSolverPtr = typedef std::weak_ptr< PsorBoxedLcpSolver >

◆ 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
	)