Namespaces
	dartsim

	mesh

	sdf

Classes
class	AddLinkExternalForceTorque

struct	ApplyExternalForceTorques

struct	ApplyGeneralizedForces

class	AttachBoxShapeFeature

class	AttachCylinderShapeFeature

class	AttachPrismaticJointFeature
	Provide the API for attaching a Link to another Link (or directly to the World) with a prismatic joint. After calling AttachPrismaticJoint the Link's parent joint will be a prismatic joint. More...

class	AttachRevoluteJointFeature
	Provide the API for attaching a Link to another Link (or directly to the World) with a revolute joint. After calling AttachRevoluteJoint, the Link's parent joint will be a revolute joint. More...

class	AttachSphereShapeFeature

class	CanReadExpectedData

class	CanReadRequiredData
	CanReadRequiredData provides compile-time static analysis to ensure that the inheriting class provides a Read(~) function overload for each of the data types that are listed as required in the Specification. It also provides a function that will invoke Read(~) on each of the required data types (you may indicate whether or not it should only invoke them on unqueried data). More...

class	CanWriteExpectedData

class	CanWriteRequiredData
	CanWriteRequiredData provides compile-time static analysis to ensure that the inheriting class provides a Write(~) function overload for each of the data types that are listed as required in the Specification. It also provides a function that will invoke Write(~) on each of the required data types (you may indicate whether or not it should only invoke them on unqueried data). More...

class	CompleteFrameSemantics
	This feature will apply frame semantics to all objects. More...

class	CompositeData
	The CompositeData class allows arbitrary data structures to be composed together, copied, and moved with type erasure. More...

struct	ConstCompatible
	Contains a static constexpr field named `value` which will be true if the type `From` has a const-quality less than or equal to the type `To`. More...

struct	ConstCompatible< To, const From >

class	ConstructEmptyLinkFeature

class	ConstructEmptyModelFeature

class	ConstructEmptyWorldFeature

struct	Contacts

struct	DataStatusMask
	This struct encodes criteria for CompositeData::DataStatus so that Read and Write operations can be done for specific types of data (ie. required and unqueried or only existing data). It is used by OperateOnSpecifiedData at run-time. More...

struct	Empty
	Useful as a blank placeholder in template metaprogramming. More...

class	Engine

class	Entity
	This is the base class of all "proxy objects". The "proxy objects" are essentially interfaces into the actual objects which exist inside of the various physics engine implementations. The proxy objects contain the minimal amount of data (e.g. a unique identifier, a reference-counter for the implementation object, and a reference to the implementation interface that it needs) necessary to interface with the object inside of the implementation that it refers to. More...

class	EntityPtr

class	ExpectData< Expected >
	ExpectData is an extension of CompositeData which indicates that the composite expects to be operating on the data types listed in its template arguments. All of the expected types will benefit from very high-speed operations when being accessed from an object of type ExpectData<Expected>. The ordinary CompositeData class needs to perform a map lookup on the data type whenever one of its functions is called, but an ExpectData<T> object does not need to perform any map lookup when performing an operation on T (e.g. .Get<T>(), .Insert<T>(), .Query<T>(), .Has<T>(), etc). More...

class	Feature
	This class defines the concept of a Feature. It should be inherited by classes that define some plugin feature. More...

struct	FeatureList
	Use a FeatureList to aggregate a list of Features. More...

struct	FeaturePolicy
	FeaturePolicy is a "policy class" used to provide metadata to features about what kind of simulation engine they are going to be used in. More...

struct	FeatureWithRequirements
	The FeatureWithRequirements class simply wraps up its required features in a FeatureList and then sets the RequiredFeatures type. More...

struct	FindExpected
	This allows us to specify that we are interested in expected data while performing template metaprogramming. More...

struct	FindFeatures

struct	FindRequired
	This allows us to specify that we are interested in required data while performing template metaprogramming. More...

struct	ForceTorque

class	ForwardStep
	ForwardStep is a feature that allows a simulation of a world to take one step forward in time. More...

struct	FrameData
	The FrameData struct fully describes the kinematic state of a Frame with "Dim" dimensions and "Scalar" precision. Dim is allowed to be 2 or 3, and Scalar is allowed to be double or float. We provide the following fully qualified types: More...

class	FrameID
	Container for specifying Frame IDs. We do not want to use a generic integer type for this, because it may lead to bugs where a plain integer is mistaken for a FrameID. This also allows the compiler to always perform argument deduction successfully. More...

class	FrameSemantics
	FrameSemantics is an Interface that can be provided by ignition-physics engines to provide users with easy ways to express kinematic quantities in terms of frames and compute their values in terms of arbitrary frames of reference. More...

class	FreeGroupFrameSemantics
	This feature provides an interface between the Model and Link classes and the FreeGroup class, which represents a group of links that are not connected to the world with any kinematic constraints. A FreeGroup can represent a single connected group of links that forms a tree with the root of the tree connected to the world with a FreeJoint, but it can also represent a group of other FreeGroups. Each FreeGroup has 1 canonical link, whose frame is used for getting and setting properties like pose and velocity. If the FreeGroup is a single tree of connected links, the canonical link should be the root of that tree. If the FreeGroup contains multiple FreeGroups, the canonical link should be selected from one of the component FreeGroups. More...

struct	FreeVector

struct	FromPolicy
	This struct is used to conveniently convert from a policy to a geometric type. Example usage: More...

struct	GeneralizedParameters

class	GetBasicJointProperties

class	GetBasicJointState

class	GetContactsFromLastStepFeature
	GetContactsFromLastStepFeature is a feature for retrieving the list of contacts generated in the previous simulation step. More...

class	GetEngineInfo

class	GetJointFromModel

class	GetLinkFromModel

class	GetModelFromWorld

class	GetShapeBoundingBox

class	GetShapeCollisionProperties

class	GetShapeFromLink

class	GetShapeKinematicProperties

class	GetWorldFromEngine

class	Identity
	This class contains fields that identify an Entity. We use this separate class in order to have tight control over how Entities can be instantiated; in particular, an Identity can only be created by a plugin implementation, so users cannot create invalid Entities. More...

struct	IsExpectedBy
	Provides a constexpr field named `value` whose value is true if and only if Data is expected by Specification. More...

struct	IsRequiredBy
	Provides a constexpr field named `value` whose value is true if and only if Data is required by Specification. More...

class	Joint

class	JointFrameSemantics
	This feature will apply frame semantics to Joint objects. More...

struct	JointPositions

class	Link

class	LinkFrameSemantics
	This feature will apply frame semantics to Link objects. More...

class	Model

class	ModelFrameSemantics
	This feature will apply frame semantics to Model objects. More...

class	OperateOnSpecifiedData
	OperateOnSpecifiedData allows us to statically analyze whether a class (Performer) can perform an operation on all the relevant types within a CompositeData Specification. It also provides functions for performing that operation. More...

struct	PIDValues

struct	Point

struct	ReadOptions
	ReadOptions provides customization for the ReadRequiredData and ReadExpectedData functions provided by CanReadRequiredData and CanReadExpectedData. More...

class	RelativeQuantity
	The RelativeQuantity class is a wrapper for classes that represent mathematical quantities (e.g. points, vectors, matrices, transforms). The purpose of this wrapper is to endow raw mathematical quantities with frame semantics, so that they can express the frame of reference of their values. More...

class	RemoveModelFromWorld

struct	RequestEngine
	This class provides utilities for inspecting what features are available in a plugin. More...

class	RequireData< Required >
	RequireData is an extension of ExpectData which indicates that the composite requires the existence of any data types that are listed in its template arguments. More...

struct	ServoControlCommands

class	SetBasicJointState

class	SetBoxShapeProperties

class	SetCylinderShapeProperties

class	SetFreeGroupWorldPose

class	SetFreeGroupWorldVelocity

class	SetJointTransformFromParentFeature

class	SetJointTransformToChildFeature

class	SetPrismaticJointProperties
	Provide the API for setting a prismatic joint's axis. Not all physics engines are able to change properties during run-time, so some might support getting the joint axis but not setting it. More...

class	SetRevoluteJointProperties
	Provide the API for setting a revolute joint's axis. Not all physics engines are able to change properties during run-time, so some might support getting the joint axis but not setting it. More...

class	SetShapeCollisionProperties

class	SetShapeKinematicProperties

class	SetSphereShapeProperties

class	Shape

class	ShapeFrameSemantics

class	SpecifyData
	The SpecifyData class allows you to form combinations of data specifications. In other words, you can freely mix invocations to RequireData and ExpectData. Example usage: More...

struct	TimeStep

struct	type
	This can be used to turn a type into a function argument, which is useful for template metaprogramming. More...

struct	VelocityControlCommands

class	World

struct	WorldPose

struct	WorldPoses

struct	WriteOptions
	A struct that defines options for writing data to a CompositeData object. More...

Typedefs
template<typename Scalar , std::size_t Dim>
using	AlignedBox = Eigen::AlignedBox< Scalar, Dim >

using	AlignedBox2d = AlignedBox< double, 2 >

using	AlignedBox2f = AlignedBox< float, 2 >

using	AlignedBox3d = AlignedBox< double, 3 >

using	AlignedBox3f = AlignedBox< float, 3 >

template<typename Scalar , std::size_t Dim>
using	AngularVector = Vector< Scalar,(Dim *(Dim-1))/2 >

using	AngularVector2d = AngularVector< double, 2 >

using	AngularVector2f = AngularVector< float, 2 >

using	AngularVector3d = AngularVector< double, 3 >

using	AngularVector3f = AngularVector< float, 3 >

using	BaseEngine2dPtr = BaseEnginePtr< ::FeaturePolicy2d >

using	BaseEngine2fPtr = BaseEnginePtr< ::FeaturePolicy2f >

using	BaseEngine3dPtr = BaseEnginePtr< ::FeaturePolicy3d >

using	BaseEngine3fPtr = BaseEnginePtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	BaseEnginePtr = ::EntityPtr< Engine< PolicyT, ::FeatureList<> >>

using	BaseJoint2dPtr = BaseJointPtr< ::FeaturePolicy2d >

using	BaseJoint2fPtr = BaseJointPtr< ::FeaturePolicy2f >

using	BaseJoint3dPtr = BaseJointPtr< ::FeaturePolicy3d >

using	BaseJoint3fPtr = BaseJointPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	BaseJointPtr = ::EntityPtr< Joint< PolicyT, ::FeatureList<> >>

using	BaseLink2dPtr = BaseLinkPtr< ::FeaturePolicy2d >

using	BaseLink2fPtr = BaseLinkPtr< ::FeaturePolicy2f >

using	BaseLink3dPtr = BaseLinkPtr< ::FeaturePolicy3d >

using	BaseLink3fPtr = BaseLinkPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	BaseLinkPtr = ::EntityPtr< Link< PolicyT, ::FeatureList<> >>

using	BaseModel2dPtr = BaseModelPtr< ::FeaturePolicy2d >

using	BaseModel2fPtr = BaseModelPtr< ::FeaturePolicy2f >

using	BaseModel3dPtr = BaseModelPtr< ::FeaturePolicy3d >

using	BaseModel3fPtr = BaseModelPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	BaseModelPtr = ::EntityPtr< Model< PolicyT, ::FeatureList<> >>

using	BaseShape2dPtr = BaseShapePtr< ::FeaturePolicy2d >

using	BaseShape2fPtr = BaseShapePtr< ::FeaturePolicy2f >

using	BaseShape3dPtr = BaseShapePtr< ::FeaturePolicy3d >

using	BaseShape3fPtr = BaseShapePtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	BaseShapePtr = ::EntityPtr< Shape< PolicyT, ::FeatureList<> >>

using	BaseWorld2dPtr = BaseWorldPtr< ::FeaturePolicy2d >

using	BaseWorld2fPtr = BaseWorldPtr< ::FeaturePolicy2f >

using	BaseWorld3dPtr = BaseWorldPtr< ::FeaturePolicy3d >

using	BaseWorld3fPtr = BaseWorldPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	BaseWorldPtr = ::EntityPtr< World< PolicyT, ::FeatureList<> >>

using	ConstBaseEngine2dPtr = ConstBaseEnginePtr< ::FeaturePolicy2d >

using	ConstBaseEngine2fPtr = ConstBaseEnginePtr< ::FeaturePolicy2f >

using	ConstBaseEngine3dPtr = ConstBaseEnginePtr< ::FeaturePolicy3d >

using	ConstBaseEngine3fPtr = ConstBaseEnginePtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	ConstBaseEnginePtr = ::EntityPtr< const Engine< PolicyT, ::FeatureList<> >>

using	ConstBaseJoint2dPtr = ConstBaseJointPtr< ::FeaturePolicy2d >

using	ConstBaseJoint2fPtr = ConstBaseJointPtr< ::FeaturePolicy2f >

using	ConstBaseJoint3dPtr = ConstBaseJointPtr< ::FeaturePolicy3d >

using	ConstBaseJoint3fPtr = ConstBaseJointPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	ConstBaseJointPtr = ::EntityPtr< const Joint< PolicyT, ::FeatureList<> >>

using	ConstBaseLink2dPtr = ConstBaseLinkPtr< ::FeaturePolicy2d >

using	ConstBaseLink2fPtr = ConstBaseLinkPtr< ::FeaturePolicy2f >

using	ConstBaseLink3dPtr = ConstBaseLinkPtr< ::FeaturePolicy3d >

using	ConstBaseLink3fPtr = ConstBaseLinkPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	ConstBaseLinkPtr = ::EntityPtr< const Link< PolicyT, ::FeatureList<> >>

using	ConstBaseModel2dPtr = ConstBaseModelPtr< ::FeaturePolicy2d >

using	ConstBaseModel2fPtr = ConstBaseModelPtr< ::FeaturePolicy2f >

using	ConstBaseModel3dPtr = ConstBaseModelPtr< ::FeaturePolicy3d >

using	ConstBaseModel3fPtr = ConstBaseModelPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	ConstBaseModelPtr = ::EntityPtr< const Model< PolicyT, ::FeatureList<> >>

using	ConstBaseShape2dPtr = ConstBaseShapePtr< ::FeaturePolicy2d >

using	ConstBaseShape2fPtr = ConstBaseShapePtr< ::FeaturePolicy2f >

using	ConstBaseShape3dPtr = ConstBaseShapePtr< ::FeaturePolicy3d >

using	ConstBaseShape3fPtr = ConstBaseShapePtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	ConstBaseShapePtr = ::EntityPtr< const Shape< PolicyT, ::FeatureList<> >>

using	ConstBaseWorld2dPtr = ConstBaseWorldPtr< ::FeaturePolicy2d >

using	ConstBaseWorld2fPtr = ConstBaseWorldPtr< ::FeaturePolicy2f >

using	ConstBaseWorld3dPtr = ConstBaseWorldPtr< ::FeaturePolicy3d >

using	ConstBaseWorld3fPtr = ConstBaseWorldPtr< ::FeaturePolicy3f >

template<typename PolicyT >
using	ConstBaseWorldPtr = ::EntityPtr< const World< PolicyT, ::FeatureList<> >>

template<typename List >
using	ConstEngine2dPtr = EnginePtr< ::FeaturePolicy2d, List >

template<typename List >
using	ConstEngine2fPtr = EnginePtr< ::FeaturePolicy2f, List >

template<typename List >
using	ConstEngine3dPtr = EnginePtr< ::FeaturePolicy3d, List >

template<typename List >
using	ConstEngine3fPtr = EnginePtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ConstEnginePtr = ::EntityPtr< const Engine< PolicyT, FeaturesT > >

template<typename List >
using	ConstJoint2dPtr = JointPtr< ::FeaturePolicy2d, List >

template<typename List >
using	ConstJoint2fPtr = JointPtr< ::FeaturePolicy2f, List >

template<typename List >
using	ConstJoint3dPtr = JointPtr< ::FeaturePolicy3d, List >

template<typename List >
using	ConstJoint3fPtr = JointPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ConstJointPtr = ::EntityPtr< const Joint< PolicyT, FeaturesT > >

template<typename List >
using	ConstLink2dPtr = LinkPtr< ::FeaturePolicy2d, List >

template<typename List >
using	ConstLink2fPtr = LinkPtr< ::FeaturePolicy2f, List >

template<typename List >
using	ConstLink3dPtr = LinkPtr< ::FeaturePolicy3d, List >

template<typename List >
using	ConstLink3fPtr = LinkPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ConstLinkPtr = ::EntityPtr< const Link< PolicyT, FeaturesT > >

template<typename List >
using	ConstModel2dPtr = ModelPtr< ::FeaturePolicy2d, List >

template<typename List >
using	ConstModel2fPtr = ModelPtr< ::FeaturePolicy2f, List >

template<typename List >
using	ConstModel3dPtr = ModelPtr< ::FeaturePolicy3d, List >

template<typename List >
using	ConstModel3fPtr = ModelPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ConstModelPtr = ::EntityPtr< const Model< PolicyT, FeaturesT > >

template<typename List >
using	ConstShape2dPtr = ShapePtr< ::FeaturePolicy2d, List >

template<typename List >
using	ConstShape2fPtr = ShapePtr< ::FeaturePolicy2f, List >

template<typename List >
using	ConstShape3dPtr = ShapePtr< ::FeaturePolicy3d, List >

template<typename List >
using	ConstShape3fPtr = ShapePtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ConstShapePtr = ::EntityPtr< const Shape< PolicyT, FeaturesT > >

template<typename List >
using	ConstWorld2dPtr = WorldPtr< ::FeaturePolicy2d, List >

template<typename List >
using	ConstWorld2fPtr = WorldPtr< ::FeaturePolicy2f, List >

template<typename List >
using	ConstWorld3dPtr = WorldPtr< ::FeaturePolicy3d, List >

template<typename List >
using	ConstWorld3fPtr = WorldPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ConstWorldPtr = ::EntityPtr< const World< PolicyT, FeaturesT > >

template<typename List >
using	Engine2d = Engine<::FeaturePolicy2d, List >

template<typename List >
using	Engine2dPtr = EnginePtr< ::FeaturePolicy2d, List >

template<typename List >
using	Engine2f = Engine<::FeaturePolicy2f, List >

template<typename List >
using	Engine2fPtr = EnginePtr< ::FeaturePolicy2f, List >

template<typename List >
using	Engine3d = Engine<::FeaturePolicy3d, List >

template<typename List >
using	Engine3dPtr = EnginePtr< ::FeaturePolicy3d, List >

template<typename List >
using	Engine3f = Engine<::FeaturePolicy3f, List >

template<typename List >
using	Engine3fPtr = EnginePtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	EnginePtr = ::EntityPtr< Engine< PolicyT, FeaturesT > >

using	FeaturePolicy2d = FeaturePolicy< double, 2 >

using	FeaturePolicy2f = FeaturePolicy< float, 2 >

using	FeaturePolicy3d = FeaturePolicy< double, 3 >

using	FeaturePolicy3f = FeaturePolicy< float, 3 >

template<typename FeatureListT >
using	FindFeatures2d = FindFeatures< FeaturePolicy2d, FeatureListT >

template<typename FeatureListT >
using	FindFeatures2f = FindFeatures< FeaturePolicy2f, FeatureListT >

template<typename FeatureListT >
using	FindFeatures3d = FindFeatures< FeaturePolicy3d, FeatureListT >

template<typename FeatureListT >
using	FindFeatures3f = FindFeatures< FeaturePolicy3f, FeatureListT >

using	GetEntities = FeatureList< GetEngineInfo, GetWorldFromEngine, GetModelFromWorld, GetLinkFromModel, GetJointFromModel, GetShapeFromLink >

template<typename PolicyT , typename FeatureListT >
using	Implements = detail::AggregateImplementation< PolicyT, FeatureListT >
	Physics plugins should inherit this class and pass it a FeatureList containing all the features that their plugin intends to implement. More...

template<typename FeatureListT >
using	Implements2d = Implements< FeaturePolicy2d, FeatureListT >

template<typename FeatureListT >
using	Implements2f = Implements< FeaturePolicy2f, FeatureListT >

template<typename FeatureListT >
using	Implements3d = Implements< FeaturePolicy3d, FeatureListT >

template<typename FeatureListT >
using	Implements3f = Implements< FeaturePolicy3f, FeatureListT >

template<typename List >
using	Joint2d = Joint<::FeaturePolicy2d, List >

template<typename List >
using	Joint2dPtr = JointPtr< ::FeaturePolicy2d, List >

template<typename List >
using	Joint2f = Joint<::FeaturePolicy2f, List >

template<typename List >
using	Joint2fPtr = JointPtr< ::FeaturePolicy2f, List >

template<typename List >
using	Joint3d = Joint<::FeaturePolicy3d, List >

template<typename List >
using	Joint3dPtr = JointPtr< ::FeaturePolicy3d, List >

template<typename List >
using	Joint3f = Joint<::FeaturePolicy3f, List >

template<typename List >
using	Joint3fPtr = JointPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	JointPtr = ::EntityPtr< Joint< PolicyT, FeaturesT > >

template<typename Scalar , std::size_t Dim>
using	LinearVector = Vector< Scalar, Dim >

using	LinearVector2d = LinearVector< double, 2 >

using	LinearVector2f = LinearVector< float, 2 >

using	LinearVector3d = LinearVector< double, 3 >

using	LinearVector3f = LinearVector< float, 3 >

template<typename List >
using	Link2d = Link<::FeaturePolicy2d, List >

template<typename List >
using	Link2dPtr = LinkPtr< ::FeaturePolicy2d, List >

template<typename List >
using	Link2f = Link<::FeaturePolicy2f, List >

template<typename List >
using	Link2fPtr = LinkPtr< ::FeaturePolicy2f, List >

template<typename List >
using	Link3d = Link<::FeaturePolicy3d, List >

template<typename List >
using	Link3dPtr = LinkPtr< ::FeaturePolicy3d, List >

template<typename List >
using	Link3f = Link<::FeaturePolicy3f, List >

template<typename List >
using	Link3fPtr = LinkPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	LinkPtr = ::EntityPtr< Link< PolicyT, FeaturesT > >

template<typename List >
using	Model2d = Model<::FeaturePolicy2d, List >

template<typename List >
using	Model2dPtr = ModelPtr< ::FeaturePolicy2d, List >

template<typename List >
using	Model2f = Model<::FeaturePolicy2f, List >

template<typename List >
using	Model2fPtr = ModelPtr< ::FeaturePolicy2f, List >

template<typename List >
using	Model3d = Model<::FeaturePolicy3d, List >

template<typename List >
using	Model3dPtr = ModelPtr< ::FeaturePolicy3d, List >

template<typename List >
using	Model3f = Model<::FeaturePolicy3f, List >

template<typename List >
using	Model3fPtr = ModelPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ModelPtr = ::EntityPtr< Model< PolicyT, FeaturesT > >

template<typename Scalar , std::size_t Dim>
using	Pose = Eigen::Transform< Scalar, Dim, Eigen::Isometry >
	This is used by ignition-physics to represent rigid body transforms in 2D or 3D simulations. The precision can be chosen as float or scalar. More...

using	Pose2d = Pose< double, 2 >

using	Pose2f = Pose< float, 2 >

using	Pose3d = Pose< double, 3 >

using	Pose3f = Pose< float, 3 >

using	RelativeAlignedBox = RelativeQuantity< AlignedBox< Scalar, Dim >, Dim, detail::AABBSpace< Scalar, Dim > >

using	RelativeForce = RelativeQuantity< LinearVector< Scalar, Dim >, Dim, detail::VectorSpace< Scalar, Dim > >

using	RelativeFrameData = RelativeQuantity< FrameData< Scalar, Dim >, Dim, detail::FrameSpace< Scalar, Dim > >

template<typename Scalar , std::size_t Dim>
using	RelativePose = RelativeQuantity< Pose< Scalar, Dim >, Dim, detail::SESpace< Scalar, Dim > >

template<typename Scalar , std::size_t Dim>
using	RelativePosition = RelativeQuantity< LinearVector< Scalar, Dim >, Dim, detail::EuclideanSpace< Scalar, Dim > >

using	RelativeQuaterniond = RelativeQuaternion< double >

using	RelativeQuaternionf = RelativeQuaternion< float >

using	RelativeRotationMatrix = RelativeQuantity< Eigen::Matrix< Scalar, Dim, Dim >, Dim, detail::SOSpace< Scalar, Dim, Eigen::Matrix< Scalar, Dim, Dim > >>

using	RelativeTorque = RelativeQuantity< AngularVector< Scalar, Dim >, Dim, detail::VectorSpace< Scalar,(Dim *(Dim-1))/2 > >

using	RemoveEntities = FeatureList< RemoveModelFromWorld >

template<typename FeatureList >
using	RequestEngine2d = RequestEngine< FeaturePolicy2d, FeatureList >

template<typename FeatureList >
using	RequestEngine2f = RequestEngine< FeaturePolicy2f, FeatureList >

template<typename FeatureList >
using	RequestEngine3d = RequestEngine< FeaturePolicy3d, FeatureList >

template<typename FeatureList >
using	RequestEngine3f = RequestEngine< FeaturePolicy3f, FeatureList >

template<typename List >
using	Shape2d = Shape<::FeaturePolicy2d, List >

template<typename List >
using	Shape2dPtr = ShapePtr< ::FeaturePolicy2d, List >

template<typename List >
using	Shape2f = Shape<::FeaturePolicy2f, List >

template<typename List >
using	Shape2fPtr = ShapePtr< ::FeaturePolicy2f, List >

template<typename List >
using	Shape3d = Shape<::FeaturePolicy3d, List >

template<typename List >
using	Shape3dPtr = ShapePtr< ::FeaturePolicy3d, List >

template<typename List >
using	Shape3f = Shape<::FeaturePolicy3f, List >

template<typename List >
using	Shape3fPtr = ShapePtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	ShapePtr = ::EntityPtr< Shape< PolicyT, FeaturesT > >

template<typename Scalar , std::size_t Dim>
using	Vector = Eigen::Matrix< Scalar, Dim, 1 >

using	Vector2d = Vector< double, 2 >

using	Vector2f = Vector< float, 2 >

using	Vector3d = Vector< double, 3 >

using	Vector3f = Vector< float, 3 >

template<typename... >
using	void_t = void

template<typename List >
using	World2d = World<::FeaturePolicy2d, List >

template<typename List >
using	World2dPtr = WorldPtr< ::FeaturePolicy2d, List >

template<typename List >
using	World2f = World<::FeaturePolicy2f, List >

template<typename List >
using	World2fPtr = WorldPtr< ::FeaturePolicy2f, List >

template<typename List >
using	World3d = World<::FeaturePolicy3d, List >

template<typename List >
using	World3dPtr = WorldPtr< ::FeaturePolicy3d, List >

template<typename List >
using	World3f = World<::FeaturePolicy3f, List >

template<typename List >
using	World3fPtr = WorldPtr< ::FeaturePolicy3f, List >

template<typename PolicyT , typename FeaturesT >
using	WorldPtr = ::EntityPtr< World< PolicyT, FeaturesT > >

Functions
template<typename Specification >
constexpr std::size_t	CountUpperLimitOfExpectedData ()
	This provides an upper limit on the number of expected data types in a CompositeData specification. This is an upper limit because when a data type is specified multiple times within a specficiation, it will be counted multiple times. As long as each data type is only specified once, it will provide an exact count. More...

template<typename Specification >
constexpr std::size_t	CountUpperLimitOfRequiredData ()
	Same as CountUpperLimitOfExpectedData() except it will count required data instead. More...

template<typename Specification , template< typename > class FindSpec>
constexpr std::size_t	CountUpperLimitOfSpecifiedData ()
	Same as CountUpperLimitOfExpectedData() except you can specify what kind of data to count using SpecFinder. SpecFinder must accept a data specification (or void) as a template argument and provide a type called Data. See FindExpected and FindRequired below for examples. More...

	IGN_PHYSICS_DECLARE_JOINT_TYPE (FixedJoint) class AttachFixedJointFeature

	IGN_PHYSICS_DECLARE_SHAPE_TYPE (BoxShape) class GetBoxShapeProperties

	IGN_PHYSICS_DECLARE_SHAPE_TYPE (CylinderShape) class GetCylinderShapeProperties

	IGN_PHYSICS_DECLARE_SHAPE_TYPE (SphereShape) class GetSphereShapeProperties

	IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS (FrameData) template< typename Scalar

	IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS (RelativePose) template< typename Scalar

	IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS (RelativeRotationMatrix) template< typename Scalar > using RelativeQuaternion

	IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS (RelativeTorque) template< typename Scalar

template<typename EntityT >
bool	operator!= (std::nullptr_t, const EntityPtr< EntityT > &_ptr)

template<typename EntityT >
bool	operator!= (const EntityPtr< EntityT > &_ptr, std::nullptr_t)

template<typename EntityT >
bool	operator!= (std::nullopt_t, const EntityPtr< EntityT > &_ptr)

template<typename EntityT >
bool	operator!= (const EntityPtr< EntityT > &_ptr, std::nullopt_t)

std::size_t Dim std::ostream &	operator<< (std::ostream &stream, const FrameData< Scalar, Dim > &_frame)

template<typename Q , std::size_t Dim, typename CoordinateSpace >
std::ostream &	operator<< (std::ostream &stream, const RelativeQuantity< Q, Dim, CoordinateSpace > &_fq)

template<typename EntityT >
bool	operator== (std::nullptr_t, const EntityPtr< EntityT > &_ptr)

template<typename EntityT >
bool	operator== (const EntityPtr< EntityT > &_ptr, std::nullptr_t)

template<typename EntityT >
bool	operator== (std::nullopt_t, const EntityPtr< EntityT > &_ptr)

template<typename EntityT >
bool	operator== (const EntityPtr< EntityT > &_ptr, std::nullopt_t)

template<typename Scalar >
Eigen::Rotation2D< Scalar >	Rotate (const Scalar &_angle, const AngularVector< Scalar, 2 > &_axis)

template<typename Scalar >
Eigen::AngleAxis< Scalar >	Rotate (const Scalar &_angle, const AngularVector< Scalar, 3 > &_axis)

Variables
const std::size_t	INVALID_ENTITY_ID
	This constant-value should be used to indicate that an Entity ID is invalid (i.e. does not refer to a real entity). More...

Typedef Documentation

◆ AlignedBox

using AlignedBox = Eigen::AlignedBox<Scalar, Dim>

◆ AlignedBox2d

using AlignedBox2d = AlignedBox <double, 2 >

◆ AlignedBox2f

using AlignedBox2f = AlignedBox <float, 2 >

◆ AlignedBox3d

using AlignedBox3d = AlignedBox <double, 3 >

◆ AlignedBox3f

using AlignedBox3f = AlignedBox <float, 3 >

◆ AngularVector

using AngularVector = Vector<Scalar, (Dim*(Dim-1))/2>

◆ AngularVector2d

using AngularVector2d = AngularVector <double, 2 >

◆ AngularVector2f

using AngularVector2f = AngularVector <float, 2 >

◆ AngularVector3d

using AngularVector3d = AngularVector <double, 3 >

◆ AngularVector3f

using AngularVector3f = AngularVector <float, 3 >

◆ BaseEngine2dPtr

using BaseEngine2dPtr = BaseEnginePtr < ::FeaturePolicy2d >

◆ BaseEngine2fPtr

using BaseEngine2fPtr = BaseEnginePtr < ::FeaturePolicy2f >

◆ BaseEngine3dPtr

using BaseEngine3dPtr = BaseEnginePtr < ::FeaturePolicy3d >

◆ BaseEngine3fPtr

using BaseEngine3fPtr = BaseEnginePtr < ::FeaturePolicy3f >

◆ BaseEnginePtr

using BaseEnginePtr = ::EntityPtr< Engine <PolicyT, ::FeatureList<> >>

◆ BaseJoint2dPtr

using BaseJoint2dPtr = BaseJointPtr < ::FeaturePolicy2d >

◆ BaseJoint2fPtr

using BaseJoint2fPtr = BaseJointPtr < ::FeaturePolicy2f >

◆ BaseJoint3dPtr

using BaseJoint3dPtr = BaseJointPtr < ::FeaturePolicy3d >

◆ BaseJoint3fPtr

using BaseJoint3fPtr = BaseJointPtr < ::FeaturePolicy3f >

◆ BaseJointPtr

using BaseJointPtr = ::EntityPtr< Joint <PolicyT, ::FeatureList<> >>

◆ BaseLink2dPtr

using BaseLink2dPtr = BaseLinkPtr < ::FeaturePolicy2d >

◆ BaseLink2fPtr

using BaseLink2fPtr = BaseLinkPtr < ::FeaturePolicy2f >

◆ BaseLink3dPtr

using BaseLink3dPtr = BaseLinkPtr < ::FeaturePolicy3d >

◆ BaseLink3fPtr

using BaseLink3fPtr = BaseLinkPtr < ::FeaturePolicy3f >

◆ BaseLinkPtr

using BaseLinkPtr = ::EntityPtr< Link <PolicyT, ::FeatureList<> >>

◆ BaseModel2dPtr

using BaseModel2dPtr = BaseModelPtr < ::FeaturePolicy2d >

◆ BaseModel2fPtr

using BaseModel2fPtr = BaseModelPtr < ::FeaturePolicy2f >

◆ BaseModel3dPtr

using BaseModel3dPtr = BaseModelPtr < ::FeaturePolicy3d >

◆ BaseModel3fPtr

using BaseModel3fPtr = BaseModelPtr < ::FeaturePolicy3f >

◆ BaseModelPtr

using BaseModelPtr = ::EntityPtr< Model <PolicyT, ::FeatureList<> >>

◆ BaseShape2dPtr

using BaseShape2dPtr = BaseShapePtr < ::FeaturePolicy2d >

◆ BaseShape2fPtr

using BaseShape2fPtr = BaseShapePtr < ::FeaturePolicy2f >

◆ BaseShape3dPtr

using BaseShape3dPtr = BaseShapePtr < ::FeaturePolicy3d >

◆ BaseShape3fPtr

using BaseShape3fPtr = BaseShapePtr < ::FeaturePolicy3f >

◆ BaseShapePtr

using BaseShapePtr = ::EntityPtr< Shape <PolicyT, ::FeatureList<> >>

◆ BaseWorld2dPtr

using BaseWorld2dPtr = BaseWorldPtr < ::FeaturePolicy2d >

◆ BaseWorld2fPtr

using BaseWorld2fPtr = BaseWorldPtr < ::FeaturePolicy2f >

◆ BaseWorld3dPtr

using BaseWorld3dPtr = BaseWorldPtr < ::FeaturePolicy3d >

◆ BaseWorld3fPtr

using BaseWorld3fPtr = BaseWorldPtr < ::FeaturePolicy3f >

◆ BaseWorldPtr

using BaseWorldPtr = ::EntityPtr< World <PolicyT, ::FeatureList<> >>

◆ ConstBaseEngine2dPtr

using ConstBaseEngine2dPtr = ConstBaseEnginePtr < ::FeaturePolicy2d >

◆ ConstBaseEngine2fPtr

using ConstBaseEngine2fPtr = ConstBaseEnginePtr < ::FeaturePolicy2f >

◆ ConstBaseEngine3dPtr

using ConstBaseEngine3dPtr = ConstBaseEnginePtr < ::FeaturePolicy3d >

◆ ConstBaseEngine3fPtr

using ConstBaseEngine3fPtr = ConstBaseEnginePtr < ::FeaturePolicy3f >

◆ ConstBaseEnginePtr

using ConstBaseEnginePtr = ::EntityPtr< const Engine <PolicyT, ::FeatureList<> >>

◆ ConstBaseJoint2dPtr

using ConstBaseJoint2dPtr = ConstBaseJointPtr < ::FeaturePolicy2d >

◆ ConstBaseJoint2fPtr

using ConstBaseJoint2fPtr = ConstBaseJointPtr < ::FeaturePolicy2f >

◆ ConstBaseJoint3dPtr

using ConstBaseJoint3dPtr = ConstBaseJointPtr < ::FeaturePolicy3d >

◆ ConstBaseJoint3fPtr

using ConstBaseJoint3fPtr = ConstBaseJointPtr < ::FeaturePolicy3f >

◆ ConstBaseJointPtr

using ConstBaseJointPtr = ::EntityPtr< const Joint <PolicyT, ::FeatureList<> >>

◆ ConstBaseLink2dPtr

using ConstBaseLink2dPtr = ConstBaseLinkPtr < ::FeaturePolicy2d >

◆ ConstBaseLink2fPtr

using ConstBaseLink2fPtr = ConstBaseLinkPtr < ::FeaturePolicy2f >

◆ ConstBaseLink3dPtr

using ConstBaseLink3dPtr = ConstBaseLinkPtr < ::FeaturePolicy3d >

◆ ConstBaseLink3fPtr

using ConstBaseLink3fPtr = ConstBaseLinkPtr < ::FeaturePolicy3f >

◆ ConstBaseLinkPtr

using ConstBaseLinkPtr = ::EntityPtr< const Link <PolicyT, ::FeatureList<> >>

◆ ConstBaseModel2dPtr

using ConstBaseModel2dPtr = ConstBaseModelPtr < ::FeaturePolicy2d >

◆ ConstBaseModel2fPtr

using ConstBaseModel2fPtr = ConstBaseModelPtr < ::FeaturePolicy2f >

◆ ConstBaseModel3dPtr

using ConstBaseModel3dPtr = ConstBaseModelPtr < ::FeaturePolicy3d >

◆ ConstBaseModel3fPtr

using ConstBaseModel3fPtr = ConstBaseModelPtr < ::FeaturePolicy3f >

◆ ConstBaseModelPtr

using ConstBaseModelPtr = ::EntityPtr< const Model <PolicyT, ::FeatureList<> >>

◆ ConstBaseShape2dPtr

using ConstBaseShape2dPtr = ConstBaseShapePtr < ::FeaturePolicy2d >

◆ ConstBaseShape2fPtr

using ConstBaseShape2fPtr = ConstBaseShapePtr < ::FeaturePolicy2f >

◆ ConstBaseShape3dPtr

using ConstBaseShape3dPtr = ConstBaseShapePtr < ::FeaturePolicy3d >

◆ ConstBaseShape3fPtr

using ConstBaseShape3fPtr = ConstBaseShapePtr < ::FeaturePolicy3f >

◆ ConstBaseShapePtr

using ConstBaseShapePtr = ::EntityPtr< const Shape <PolicyT, ::FeatureList<> >>

◆ ConstBaseWorld2dPtr

using ConstBaseWorld2dPtr = ConstBaseWorldPtr < ::FeaturePolicy2d >

◆ ConstBaseWorld2fPtr

using ConstBaseWorld2fPtr = ConstBaseWorldPtr < ::FeaturePolicy2f >

◆ ConstBaseWorld3dPtr

using ConstBaseWorld3dPtr = ConstBaseWorldPtr < ::FeaturePolicy3d >

◆ ConstBaseWorld3fPtr

using ConstBaseWorld3fPtr = ConstBaseWorldPtr < ::FeaturePolicy3f >

◆ ConstBaseWorldPtr

using ConstBaseWorldPtr = ::EntityPtr< const World <PolicyT, ::FeatureList<> >>

◆ ConstEngine2dPtr

using ConstEngine2dPtr = EnginePtr < ::FeaturePolicy2d , List>

◆ ConstEngine2fPtr

using ConstEngine2fPtr = EnginePtr < ::FeaturePolicy2f , List>

◆ ConstEngine3dPtr

using ConstEngine3dPtr = EnginePtr < ::FeaturePolicy3d , List>

◆ ConstEngine3fPtr

using ConstEngine3fPtr = EnginePtr < ::FeaturePolicy3f , List>

◆ ConstEnginePtr

using ConstEnginePtr = ::EntityPtr< const Engine <PolicyT, FeaturesT> >

◆ ConstJoint2dPtr

using ConstJoint2dPtr = JointPtr < ::FeaturePolicy2d , List>

◆ ConstJoint2fPtr

using ConstJoint2fPtr = JointPtr < ::FeaturePolicy2f , List>

◆ ConstJoint3dPtr

using ConstJoint3dPtr = JointPtr < ::FeaturePolicy3d , List>

◆ ConstJoint3fPtr

using ConstJoint3fPtr = JointPtr < ::FeaturePolicy3f , List>

◆ ConstJointPtr

using ConstJointPtr = ::EntityPtr< const Joint <PolicyT, FeaturesT> >

◆ ConstLink2dPtr

using ConstLink2dPtr = LinkPtr < ::FeaturePolicy2d , List>

◆ ConstLink2fPtr

using ConstLink2fPtr = LinkPtr < ::FeaturePolicy2f , List>

◆ ConstLink3dPtr

using ConstLink3dPtr = LinkPtr < ::FeaturePolicy3d , List>

◆ ConstLink3fPtr

using ConstLink3fPtr = LinkPtr < ::FeaturePolicy3f , List>

◆ ConstLinkPtr

using ConstLinkPtr = ::EntityPtr< const Link <PolicyT, FeaturesT> >

◆ ConstModel2dPtr

using ConstModel2dPtr = ModelPtr < ::FeaturePolicy2d , List>

◆ ConstModel2fPtr

using ConstModel2fPtr = ModelPtr < ::FeaturePolicy2f , List>

◆ ConstModel3dPtr

using ConstModel3dPtr = ModelPtr < ::FeaturePolicy3d , List>

◆ ConstModel3fPtr

using ConstModel3fPtr = ModelPtr < ::FeaturePolicy3f , List>

◆ ConstModelPtr

using ConstModelPtr = ::EntityPtr< const Model <PolicyT, FeaturesT> >

◆ ConstShape2dPtr

using ConstShape2dPtr = ShapePtr < ::FeaturePolicy2d , List>

◆ ConstShape2fPtr

using ConstShape2fPtr = ShapePtr < ::FeaturePolicy2f , List>

◆ ConstShape3dPtr

using ConstShape3dPtr = ShapePtr < ::FeaturePolicy3d , List>

◆ ConstShape3fPtr

using ConstShape3fPtr = ShapePtr < ::FeaturePolicy3f , List>

◆ ConstShapePtr

using ConstShapePtr = ::EntityPtr< const Shape <PolicyT, FeaturesT> >

◆ ConstWorld2dPtr

using ConstWorld2dPtr = WorldPtr < ::FeaturePolicy2d , List>

◆ ConstWorld2fPtr

using ConstWorld2fPtr = WorldPtr < ::FeaturePolicy2f , List>

◆ ConstWorld3dPtr

using ConstWorld3dPtr = WorldPtr < ::FeaturePolicy3d , List>

◆ ConstWorld3fPtr

using ConstWorld3fPtr = WorldPtr < ::FeaturePolicy3f , List>

◆ ConstWorldPtr

using ConstWorldPtr = ::EntityPtr< const World <PolicyT, FeaturesT> >

◆ Engine2d

using Engine2d = Engine <::FeaturePolicy2d , List>

◆ Engine2dPtr

using Engine2dPtr = EnginePtr < ::FeaturePolicy2d , List>

◆ Engine2f

using Engine2f = Engine <::FeaturePolicy2f , List>

◆ Engine2fPtr

using Engine2fPtr = EnginePtr < ::FeaturePolicy2f , List>

◆ Engine3d

using Engine3d = Engine <::FeaturePolicy3d , List>

◆ Engine3dPtr

using Engine3dPtr = EnginePtr < ::FeaturePolicy3d , List>

◆ Engine3f

using Engine3f = Engine <::FeaturePolicy3f , List>

◆ Engine3fPtr

using Engine3fPtr = EnginePtr < ::FeaturePolicy3f , List>

◆ EnginePtr

using EnginePtr = ::EntityPtr< Engine <PolicyT, FeaturesT> >

◆ FeaturePolicy2d

using FeaturePolicy2d = FeaturePolicy<double, 2>

◆ FeaturePolicy2f

using FeaturePolicy2f = FeaturePolicy<float, 2>

◆ FeaturePolicy3d

using FeaturePolicy3d = FeaturePolicy<double, 3>

◆ FeaturePolicy3f

using FeaturePolicy3f = FeaturePolicy<float, 3>

◆ FindFeatures2d

using FindFeatures2d = FindFeatures<FeaturePolicy2d, FeatureListT>

◆ FindFeatures2f

using FindFeatures2f = FindFeatures<FeaturePolicy2f, FeatureListT>

◆ FindFeatures3d

using FindFeatures3d = FindFeatures<FeaturePolicy3d, FeatureListT>

◆ FindFeatures3f

using FindFeatures3f = FindFeatures<FeaturePolicy3f, FeatureListT>

◆ GetEntities

using GetEntities = FeatureList< GetEngineInfo, GetWorldFromEngine, GetModelFromWorld, GetLinkFromModel, GetJointFromModel, GetShapeFromLink >

◆ Implements

using Implements = detail::AggregateImplementation<PolicyT, FeatureListT>

Physics plugins should inherit this class and pass it a FeatureList containing all the features that their plugin intends to implement.

Below are simpler templates that hardcode the dimensionality and precision.

◆ Implements2d

using Implements2d = Implements<FeaturePolicy2d, FeatureListT>

◆ Implements2f

using Implements2f = Implements<FeaturePolicy2f, FeatureListT>

◆ Implements3d

using Implements3d = Implements<FeaturePolicy3d, FeatureListT>

◆ Implements3f

using Implements3f = Implements<FeaturePolicy3f, FeatureListT>

◆ Joint2d

using Joint2d = Joint <::FeaturePolicy2d , List>

◆ Joint2dPtr

using Joint2dPtr = JointPtr < ::FeaturePolicy2d , List>

◆ Joint2f

using Joint2f = Joint <::FeaturePolicy2f , List>

◆ Joint2fPtr

using Joint2fPtr = JointPtr < ::FeaturePolicy2f , List>

◆ Joint3d

using Joint3d = Joint <::FeaturePolicy3d , List>

◆ Joint3dPtr

using Joint3dPtr = JointPtr < ::FeaturePolicy3d , List>

◆ Joint3f

using Joint3f = Joint <::FeaturePolicy3f , List>

◆ Joint3fPtr

using Joint3fPtr = JointPtr < ::FeaturePolicy3f , List>

◆ JointPtr

using JointPtr = ::EntityPtr< Joint <PolicyT, FeaturesT> >

◆ LinearVector

using LinearVector = Vector<Scalar, Dim>

◆ LinearVector2d

using LinearVector2d = LinearVector <double, 2 >

◆ LinearVector2f

using LinearVector2f = LinearVector <float, 2 >

◆ LinearVector3d

using LinearVector3d = LinearVector <double, 3 >

◆ LinearVector3f

using LinearVector3f = LinearVector <float, 3 >

◆ Link2d

using Link2d = Link <::FeaturePolicy2d , List>

◆ Link2dPtr

using Link2dPtr = LinkPtr < ::FeaturePolicy2d , List>

◆ Link2f

using Link2f = Link <::FeaturePolicy2f , List>

◆ Link2fPtr

using Link2fPtr = LinkPtr < ::FeaturePolicy2f , List>

◆ Link3d

using Link3d = Link <::FeaturePolicy3d , List>

◆ Link3dPtr

using Link3dPtr = LinkPtr < ::FeaturePolicy3d , List>

◆ Link3f

using Link3f = Link <::FeaturePolicy3f , List>

◆ Link3fPtr

using Link3fPtr = LinkPtr < ::FeaturePolicy3f , List>

◆ LinkPtr

using LinkPtr = ::EntityPtr< Link <PolicyT, FeaturesT> >

◆ Model2d

using Model2d = Model <::FeaturePolicy2d , List>

◆ Model2dPtr

using Model2dPtr = ModelPtr < ::FeaturePolicy2d , List>

◆ Model2f

using Model2f = Model <::FeaturePolicy2f , List>

◆ Model2fPtr

using Model2fPtr = ModelPtr < ::FeaturePolicy2f , List>

◆ Model3d

using Model3d = Model <::FeaturePolicy3d , List>

◆ Model3dPtr

using Model3dPtr = ModelPtr < ::FeaturePolicy3d , List>

◆ Model3f

using Model3f = Model <::FeaturePolicy3f , List>

◆ Model3fPtr

using Model3fPtr = ModelPtr < ::FeaturePolicy3f , List>

◆ ModelPtr

using ModelPtr = ::EntityPtr< Model <PolicyT, FeaturesT> >

◆ Pose

using Pose = Eigen::Transform<Scalar, Dim, Eigen::Isometry>

This is used by ignition-physics to represent rigid body transforms in 2D or 3D simulations. The precision can be chosen as float or scalar.

◆ Pose2d

using Pose2d = Pose <double, 2 >

◆ Pose2f

using Pose2f = Pose <float, 2 >

◆ Pose3d

using Pose3d = Pose <double, 3 >

◆ Pose3f

using Pose3f = Pose <float, 3 >

◆ RelativeAlignedBox

using RelativeAlignedBox = RelativeQuantity< AlignedBox<Scalar, Dim>, Dim, detail::AABBSpace<Scalar, Dim> >

◆ RelativeForce

using RelativeForce = RelativeQuantity< LinearVector<Scalar, Dim>, Dim, detail::VectorSpace<Scalar, Dim> >

◆ RelativeFrameData

using RelativeFrameData = RelativeQuantity< FrameData<Scalar, Dim>, Dim, detail::FrameSpace<Scalar, Dim> >

◆ RelativePose

using RelativePose = RelativeQuantity< Pose<Scalar, Dim>, Dim, detail::SESpace<Scalar, Dim> >

◆ RelativePosition

using RelativePosition = RelativeQuantity< LinearVector<Scalar, Dim>, Dim, detail::EuclideanSpace<Scalar, Dim> >

◆ RelativeQuaterniond

using RelativeQuaterniond = RelativeQuaternion<double>

◆ RelativeQuaternionf

using RelativeQuaternionf = RelativeQuaternion<float>

◆ RelativeRotationMatrix

using RelativeRotationMatrix = RelativeQuantity< Eigen::Matrix<Scalar, Dim, Dim>, Dim, detail::SOSpace<Scalar, Dim, Eigen::Matrix<Scalar, Dim, Dim> >>

◆ RelativeTorque

using RelativeTorque = RelativeQuantity< AngularVector<Scalar, Dim>, Dim, detail::VectorSpace<Scalar, (Dim*(Dim-1))/2> >

◆ RemoveEntities

using RemoveEntities = FeatureList< RemoveModelFromWorld >

◆ RequestEngine2d

using RequestEngine2d = RequestEngine<FeaturePolicy2d , FeatureList>

◆ RequestEngine2f

using RequestEngine2f = RequestEngine<FeaturePolicy2f , FeatureList>

◆ RequestEngine3d

using RequestEngine3d = RequestEngine<FeaturePolicy3d , FeatureList>

◆ RequestEngine3f

using RequestEngine3f = RequestEngine<FeaturePolicy3f , FeatureList>

◆ Shape2d

using Shape2d = Shape <::FeaturePolicy2d , List>

◆ Shape2dPtr

using Shape2dPtr = ShapePtr < ::FeaturePolicy2d , List>

◆ Shape2f

using Shape2f = Shape <::FeaturePolicy2f , List>

◆ Shape2fPtr

using Shape2fPtr = ShapePtr < ::FeaturePolicy2f , List>

◆ Shape3d

using Shape3d = Shape <::FeaturePolicy3d , List>

◆ Shape3dPtr

using Shape3dPtr = ShapePtr < ::FeaturePolicy3d , List>

◆ Shape3f

using Shape3f = Shape <::FeaturePolicy3f , List>

◆ Shape3fPtr

using Shape3fPtr = ShapePtr < ::FeaturePolicy3f , List>

◆ ShapePtr

using ShapePtr = ::EntityPtr< Shape <PolicyT, FeaturesT> >

◆ Vector

using Vector = Eigen::Matrix<Scalar, Dim, 1>

◆ Vector2d

using Vector2d = Vector <double, 2 >

◆ Vector2f

using Vector2f = Vector <float, 2 >

◆ Vector3d

using Vector3d = Vector <double, 3 >

◆ Vector3f

using Vector3f = Vector <float, 3 >

◆ void_t

using void_t = void

TODO(MXG): Remove this and use std::void_t instead when migrating to C++17

◆ World2d

using World2d = World <::FeaturePolicy2d , List>

◆ World2dPtr

using World2dPtr = WorldPtr < ::FeaturePolicy2d , List>

◆ World2f

using World2f = World <::FeaturePolicy2f , List>

◆ World2fPtr

using World2fPtr = WorldPtr < ::FeaturePolicy2f , List>

◆ World3d

using World3d = World <::FeaturePolicy3d , List>

◆ World3dPtr

using World3dPtr = WorldPtr < ::FeaturePolicy3d , List>

◆ World3f

using World3f = World <::FeaturePolicy3f , List>

◆ World3fPtr

using World3fPtr = WorldPtr < ::FeaturePolicy3f , List>

◆ WorldPtr

using WorldPtr = ::EntityPtr< World <PolicyT, FeaturesT> >

Function Documentation

◆ CountUpperLimitOfExpectedData()

constexpr std::size_t CountUpperLimitOfExpectedData ( )

This provides an upper limit on the number of expected data types in a CompositeData specification. This is an upper limit because when a data type is specified multiple times within a specficiation, it will be counted multiple times. As long as each data type is only specified once, it will provide an exact count.

This is a constexpr so it will be evaluated at compile-time and behaves like a constant literal.

◆ CountUpperLimitOfRequiredData()

constexpr std::size_t CountUpperLimitOfRequiredData ( )

Same as CountUpperLimitOfExpectedData() except it will count required data instead.

◆ CountUpperLimitOfSpecifiedData()

constexpr std::size_t CountUpperLimitOfSpecifiedData ( )

Same as CountUpperLimitOfExpectedData() except you can specify what kind of data to count using SpecFinder. SpecFinder must accept a data specification (or void) as a template argument and provide a type called Data. See FindExpected and FindRequired below for examples.

Referenced by OperateOnSpecifiedData< Specification, SpecFinder, Operation, Performer >::Operate().

◆ IGN_PHYSICS_DECLARE_JOINT_TYPE()

ignition::physics::IGN_PHYSICS_DECLARE_JOINT_TYPE ( FixedJoint )

Attach this link to another link using a FixedJoint.

Parameters

[in]	_parent	The parent link for the joint. Pass in a nullptr to attach the link to the world.
[in]	_name	The name for this joint.

Returns: A reference to the newly constructed FixedJoint. You can use the SetJointTransformFromParentFeature and SetJointTransformToChildFeature on this JointPtr to set the relative transform between the parent and child if your physics engine offers those features.

◆ IGN_PHYSICS_DECLARE_SHAPE_TYPE() [1/3]

ignition::physics::IGN_PHYSICS_DECLARE_SHAPE_TYPE ( BoxShape )

Get the dimensions of this BoxShape

Returns: the dimensions of this BoxShape

◆ IGN_PHYSICS_DECLARE_SHAPE_TYPE() [2/3]

ignition::physics::IGN_PHYSICS_DECLARE_SHAPE_TYPE ( CylinderShape )

Get the radius of this CylinderShape

Returns: the radius of this CylinderShape

Get the height (length along the local z-axis) of this CylinderShape.

Returns: the height of this CylinderShape

◆ IGN_PHYSICS_DECLARE_SHAPE_TYPE() [3/3]

ignition::physics::IGN_PHYSICS_DECLARE_SHAPE_TYPE ( SphereShape )

Get the radius of this SphereShape

Returns: the radius of this SphereShape

◆ IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS() [1/4]

ignition::physics::IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS ( FrameData )

◆ IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS() [2/4]

IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS ( RelativePose )

◆ IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS() [3/4]

ignition::physics::IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS ( RelativeRotationMatrix )

◆ IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS() [4/4]

ignition::physics::IGN_PHYSICS_MAKE_ALL_TYPE_COMBOS ( RelativeTorque )

◆ operator!=() [1/4]

bool ignition::physics::operator!=	(	std::nullptr_t	,
		const EntityPtr< EntityT > &	_ptr
	)

◆ operator!=() [2/4]

bool ignition::physics::operator!=	(	const EntityPtr< EntityT > &	_ptr,
		std::nullptr_t
	)

◆ operator!=() [3/4]

bool ignition::physics::operator!=	(	std::nullopt_t	,
		const EntityPtr< EntityT > &	_ptr
	)

◆ operator!=() [4/4]

bool ignition::physics::operator!=	(	const EntityPtr< EntityT > &	_ptr,
		std::nullopt_t
	)

◆ operator<<() [1/2]

std::size_t Dim std::ostream& ignition::physics::operator<<	(	std::ostream &	stream,
		const FrameData< Scalar, Dim > &	_frame
	)

References FrameData< Scalar, Dim >::angularAcceleration, FrameData< Scalar, Dim >::angularVelocity, FrameData< Scalar, Dim >::linearAcceleration, FrameData< Scalar, Dim >::linearVelocity, and FrameData< Scalar, Dim >::pose.

◆ operator<<() [2/2]

std::ostream& ignition::physics::operator<<	(	std::ostream &	stream,
		const RelativeQuantity< Q, Dim, CoordinateSpace > &	_fq
	)

References RelativeQuantity< Q, Dim, CoordinateSpace >::ParentFrame(), and RelativeQuantity< Q, Dim, CoordinateSpace >::RelativeToParent().

◆ operator==() [1/4]

bool ignition::physics::operator==	(	std::nullptr_t	,
		const EntityPtr< EntityT > &	_ptr
	)

◆ operator==() [2/4]

bool ignition::physics::operator==	(	const EntityPtr< EntityT > &	_ptr,
		std::nullptr_t
	)

References EntityPtr< EntityT >::Valid().

◆ operator==() [3/4]

bool ignition::physics::operator==	(	std::nullopt_t	,
		const EntityPtr< EntityT > &	_ptr
	)

References EntityPtr< EntityT >::Valid().

◆ operator==() [4/4]

bool ignition::physics::operator==	(	const EntityPtr< EntityT > &	_ptr,
		std::nullopt_t
	)

References EntityPtr< EntityT >::Valid().

◆ Rotate() [1/2]

Eigen::Rotation2D<Scalar> ignition::physics::Rotate	(	const Scalar &	_angle,
		const AngularVector< Scalar, 2 > &	_axis
	)

◆ Rotate() [2/2]

Eigen::AngleAxis<Scalar> ignition::physics::Rotate	(	const Scalar &	_angle,
		const AngularVector< Scalar, 3 > &	_axis
	)

Variable Documentation

◆ INVALID_ENTITY_ID

const std::size_t INVALID_ENTITY_ID

Initial value:

=

std::numeric_limits<std::size_t>::max()

std::numeric_limits::max

T max(T... args)

This constant-value should be used to indicate that an Entity ID is invalid (i.e. does not refer to a real entity).

Referenced by EntityPtr< PolicyT, FeaturesT >::Hash().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AlignedBox

◆ AlignedBox2d

◆ AlignedBox2f

◆ AlignedBox3d

◆ AlignedBox3f

◆ AngularVector

◆ AngularVector2d

◆ AngularVector2f

◆ AngularVector3d

◆ AngularVector3f

◆ BaseEngine2dPtr

◆ BaseEngine2fPtr

◆ BaseEngine3dPtr

◆ BaseEngine3fPtr

◆ BaseEnginePtr

◆ BaseJoint2dPtr

◆ BaseJoint2fPtr

◆ BaseJoint3dPtr

◆ BaseJoint3fPtr

◆ BaseJointPtr

◆ BaseLink2dPtr

◆ BaseLink2fPtr

◆ BaseLink3dPtr

◆ BaseLink3fPtr

◆ BaseLinkPtr

◆ BaseModel2dPtr

◆ BaseModel2fPtr

◆ BaseModel3dPtr

◆ BaseModel3fPtr

◆ BaseModelPtr

◆ BaseShape2dPtr

◆ BaseShape2fPtr

◆ BaseShape3dPtr

◆ BaseShape3fPtr

◆ BaseShapePtr

◆ BaseWorld2dPtr

◆ BaseWorld2fPtr

◆ BaseWorld3dPtr

◆ BaseWorld3fPtr

◆ BaseWorldPtr

◆ ConstBaseEngine2dPtr

◆ ConstBaseEngine2fPtr

◆ ConstBaseEngine3dPtr

◆ ConstBaseEngine3fPtr

◆ ConstBaseEnginePtr

◆ ConstBaseJoint2dPtr

◆ ConstBaseJoint2fPtr

◆ ConstBaseJoint3dPtr

◆ ConstBaseJoint3fPtr

◆ ConstBaseJointPtr

◆ ConstBaseLink2dPtr

◆ ConstBaseLink2fPtr

◆ ConstBaseLink3dPtr

◆ ConstBaseLink3fPtr

◆ ConstBaseLinkPtr

◆ ConstBaseModel2dPtr

◆ ConstBaseModel2fPtr

◆ ConstBaseModel3dPtr

◆ ConstBaseModel3fPtr

◆ ConstBaseModelPtr

◆ ConstBaseShape2dPtr

◆ ConstBaseShape2fPtr

◆ ConstBaseShape3dPtr

◆ ConstBaseShape3fPtr

◆ ConstBaseShapePtr

◆ ConstBaseWorld2dPtr

◆ ConstBaseWorld2fPtr

◆ ConstBaseWorld3dPtr

◆ ConstBaseWorld3fPtr

◆ ConstBaseWorldPtr

◆ ConstEngine2dPtr

◆ ConstEngine2fPtr

◆ ConstEngine3dPtr

◆ ConstEngine3fPtr