| CApplyExternalForceTorques | |
| CApplyGeneralizedForces | |
| CCanReadExpectedData< Derived, Specification > | |
| CCanReadRequiredData< Derived, Specification > | 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) |
| CCanWriteExpectedData< Derived, Specification > | |
| CCanWriteRequiredData< Derived, Specification > | 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) |
| CChangedWorldPoses | ChangedWorldPoses has the same definition as WorldPoses. This type provides a way to keep track of which poses have changed in a simulation step |
| ►CCompositeData | Allows arbitrary data structures to be composed together, copied, and moved with type erasure |
| CExpectData< 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) |
| CGetContactsFromLastStepFeature::Implementation< PolicyT >::ContactInternal | |
| CGetContactsFromLastStepFeature::World< PolicyT, FeaturesT >::ContactPoint | |
| CContacts | |
| CSetContactPropertiesCallbackFeature::ContactSurfaceParams< PolicyT > | This struct gets filled by the simulator and contains various properties of a contact joint (surface, constraint). All of the values are optional, which means that they are only filled if the physics engine supports them. Some originally unfilled values may still be processed by the physics engine if they are set - this just means there is no default value for them |
| CCompositeData::DataStatus | Struct that describes the status of data |
| CDataStatusMask | 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 |
| CEmpty | Useful as a blank placeholder in template metaprogramming |
| ►CEntity< PolicyT, FeaturesT > | 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 |
| ►CFeature::Engine< PolicyT, FeaturesT > | |
| CConstructEmptyWorldFeature::Engine< PolicyT, FeaturesT > | |
| CFrameSemantics::Engine< PolicyT, FeaturesT > | This class defines the engine interface that provides the FrameSemantics feature |
| CGetEngineInfo::Engine< PolicyT, FeaturesT > | |
| CGetWorldFromEngine::Engine< PolicyT, FeaturesT > | |
| CConstructSdfWorld::Engine< PolicyT, FeaturesT > | |
| ►CFeature::Joint< PolicyT, FeaturesT > | |
| CDetachJointFeature::Joint< PolicyT, FeaturesT > | |
| CGetBasicJointProperties::Joint< PolicyT, FeaturesT > | The Joint API for getting basic joint properties |
| CGetBasicJointState::Joint< PolicyT, FeaturesT > | The Joint API for getting basic joint state |
| CGetJointFromModel::Joint< PolicyT, FeaturesT > | |
| CSetBasicJointState::Joint< PolicyT, FeaturesT > | The Joint API for setting basic joint state |
| CSetJointEffortLimitsFeature::Joint< PolicyT, FeaturesT > | The Joint API for setting effort limits of a joint. These limits are applied to joints controlled via positional, velocity or effort commands |
| CSetJointPositionLimitsFeature::Joint< PolicyT, FeaturesT > | The Joint API for setting position limits of a joint |
| CSetJointTransformFromParentFeature::Joint< PolicyT, FeaturesT > | The Joint API for setting the transform from the joint's parent |
| CSetJointTransformToChildFeature::Joint< PolicyT, FeaturesT > | The Joint API for setting the transform to the joint's child |
| CSetJointVelocityCommandFeature::Joint< PolicyT, FeaturesT > | The Joint API for setting velocity commands (target velocity). This is different from SetVelocity in that this does not modify the internal state of the joint. Instead, the physics engine is expected to compute the necessary joint torque for the commanded velocity and apply it in the next simulation step |
| CSetJointVelocityLimitsFeature::Joint< PolicyT, FeaturesT > | The Joint API for setting velocity limits of a joint. These limits apply to joints commanded via velocity or positional commands |
| CSetMimicConstraintFeature::Joint< PolicyT, FeaturesT > | |
| ►CFeature::Link< PolicyT, FeaturesT > | |
| CAddedMass::Link< PolicyT, FeaturesT > | |
| CAttachBoxShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachCapsuleShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachConeShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachCylinderShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachEllipsoidShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachPlaneShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachPrismaticJointFeature::Link< PolicyT, FeaturesT > | |
| CAttachRevoluteJointFeature::Link< PolicyT, FeaturesT > | |
| CAttachSphereShapeFeature::Link< PolicyT, FeaturesT > | |
| CGetLinkFromModel::Link< PolicyT, FeaturesT > | |
| ►CGetShapeFromLink::Link< PolicyT, FeaturesT > | |
| CGetLinkBoundingBox::Link< PolicyT, FeaturesT > | |
| CAttachHeightmapShapeFeature::Link< PolicyT, FeaturesT > | |
| CAttachMeshShapeFeature::Link< PolicyT, FeaturesT > | |
| CConstructSdfCollision::Link< PolicyT, FeaturesT > | |
| CConstructSdfVisual::Link< PolicyT, FeaturesT > | |
| ►CFeature::Model< PolicyT, FeaturesT > | |
| CConstructEmptyLinkFeature::Model< PolicyT, FeaturesT > | |
| CConstructEmptyNestedModelFeature::Model< PolicyT, FeaturesT > | |
| CGetJointFromModel::Model< PolicyT, FeaturesT > | |
| CGetLinkFromModel::Model< PolicyT, FeaturesT > | |
| CGetModelBoundingBox::Model< PolicyT, FeaturesT > | |
| CGetModelFromWorld::Model< PolicyT, FeaturesT > | |
| CGetNestedModelFromModel::Model< PolicyT, FeaturesT > | |
| CRemoveModelFromWorld::Model< PolicyT, FeaturesT > | |
| CRemoveNestedModelFromModel::Model< PolicyT, FeaturesT > | |
| CConstructSdfJoint::Model< PolicyT, FeaturesT > | |
| CConstructSdfLink::Model< PolicyT, FeaturesT > | |
| CConstructSdfNestedModel::Model< PolicyT, FeaturesT > | |
| ►CFeature::Shape< PolicyT, FeaturesT > | |
| CCollisionFilterMaskFeature::Shape< PolicyT, FeaturesT > | |
| CGetShapeCollisionProperties::Shape< PolicyT, FeaturesT > | |
| CGetShapeFrictionPyramidSlipCompliance::Shape< PolicyT, FeaturesT > | |
| CGetShapeFromLink::Shape< PolicyT, FeaturesT > | |
| CGetShapeKinematicProperties::Shape< PolicyT, FeaturesT > | |
| CSetShapeCollisionProperties::Shape< PolicyT, FeaturesT > | |
| CSetShapeFrictionPyramidSlipCompliance::Shape< PolicyT, FeaturesT > | |
| CSetShapeKinematicProperties::Shape< PolicyT, FeaturesT > | |
| ►CFeature::World< PolicyT, FeaturesT > | |
| CCollisionDetector::World< PolicyT, FeaturesT > | The World API for setting the collision detector |
| CCollisionPairMaxContacts::World< PolicyT, FeaturesT > | The World API for getting and setting the maximum number of contacts between two entities |
| CConstructEmptyModelFeature::World< PolicyT, FeaturesT > | |
| CForwardStep::World< PolicyT, FeaturesT > | |
| CGetContactsFromLastStepFeature::World< PolicyT, FeaturesT > | |
| CGetModelFromWorld::World< PolicyT, FeaturesT > | |
| CGetRayIntersectionFromLastStepFeature::World< PolicyT, FeaturesT > | |
| CGetWorldFromEngine::World< PolicyT, FeaturesT > | |
| CGravity::World< PolicyT, FeaturesT > | The World API for getting and setting the gravity vector |
| CRemoveModelFromWorld::World< PolicyT, FeaturesT > | |
| CSetContactPropertiesCallbackFeature::World< PolicyT, FeaturesT > | |
| CSolver::World< PolicyT, FeaturesT > | The World API for setting the solver |
| CWorldModelFeature::World< PolicyT, FeaturesT > | |
| CConstructSdfModel::World< PolicyT, FeaturesT > | |
| CConstructSdfNestedModel::World< PolicyT, FeaturesT > | |
| ►CFrameSemantics::Frame< PolicyT, FeaturesT > | Base class for the API of a Frame. This will be inherited by any objects that are able to express Frame Semantics |
| CAddLinkExternalForceTorque::Link< PolicyT, FeaturesT > | The Link API for adding link force/torque |
| CGetJointTransmittedWrench::Joint< PolicyT, FeaturesT > | |
| CGetShapeBoundingBox::Shape< PolicyT, FeaturesT > | |
| CSetBoxShapeProperties::BoxShape< PolicyT, FeaturesT > | |
| CSetCapsuleShapeProperties::CapsuleShape< PolicyT, FeaturesT > | |
| CSetConeShapeProperties::ConeShape< PolicyT, FeaturesT > | |
| CSetCylinderShapeProperties::CylinderShape< PolicyT, FeaturesT > | |
| CSetEllipsoidShapeProperties::EllipsoidShape< PolicyT, FeaturesT > | |
| CSetFreeGroupWorldPose::FreeGroup< PolicyT, FeaturesT > | This class defines the FreeGroup concept, which represents a group of links that are not connected to the world with any kinematic constraints. This class also provides a rough definition of this FreeGroup pose in world frame. See FindFreeGroupFeature class documentation for more detail |
| CSetFreeGroupWorldVelocity::FreeGroup< PolicyT, FeaturesT > | This class defines the FreeGroup concept, which represents a group of links that are not connected to the world with any kinematic constraints. This class also provides a rough definition of this FreeGroup linear and angular velocity in world frame. See FindFreeGroupFeature class documentation for more detail |
| CSetPlaneShapeProperties::PlaneShape< PolicyT, FeaturesT > | |
| CSetPrismaticJointProperties::PrismaticJoint< PolicyT, FeaturesT > | The API for setting basic prismatic joint properties |
| CSetRevoluteJointProperties::RevoluteJoint< PolicyT, FeaturesT > | The API for setting basic revolute joint properties |
| CSetSphereShapeProperties::SphereShape< PolicyT, FeaturesT > | |
| CSetMeshShapeProperties::MeshShape< PolicyT, FeaturesT > | |
| ►CEntity< Policy, FeaturesT > | |
| CFeature::Engine< Policy, FeaturesT > | Placeholder class for the Engine API. Every Engine feature MUST inherit this class |
| CFeature::Joint< Policy, FeaturesT > | Placeholder class in case a Feature does not define its own Joint API |
| CFeature::Link< Policy, FeaturesT > | Placeholder class in case a Feature does not define its own Link API |
| CFeature::Model< Policy, FeaturesT > | Placeholder class in case a Feature does not define its own Model API |
| CFeature::Shape< Policy, FeaturesT > | Placeholder class in case a Feature does not define its own Shape API |
| CFeature::World< Policy, FeaturesT > | Placeholder class in case a Feature does not define its own World API |
| CEntityPtr< EntityT > | |
| ►CExpectData | |
| CRequireData< 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 |
| CGetContactsFromLastStepFeature::ExtraContactDataT< PolicyT > | |
| ►CFeature | This class defines the concept of a Feature. It should be inherited by classes that define some plugin feature |
| CAddedMass | |
| CCollisionDetector | |
| CCollisionFilterMaskFeature | |
| CCollisionPairMaxContacts | |
| CConstructEmptyLinkFeature | This feature constructs an empty link and returns its pointer from the given model |
| CConstructEmptyModelFeature | [ConstructEmptyWorld] |
| CConstructEmptyNestedModelFeature | This feature constructs an empty nested model and returns its pointer from the given world |
| CConstructEmptyWorldFeature | This feature constructs an empty world and returns its pointer from the current physics engine in use |
| CDetachJointFeature | |
| CForwardStep | ForwardStep is a feature that allows a simulation of a world to take one step forward in time |
| ►CFrameSemantics | FrameSemantics is an Interface that can be provided by gz-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 |
| ►CJointFrameSemantics | This feature will apply frame semantics to Joint objects |
| CCompleteFrameSemantics | This feature will apply frame semantics to all objects |
| ►CLinkFrameSemantics | This feature will apply frame semantics to Link objects |
| CCompleteFrameSemantics | This feature will apply frame semantics to all objects |
| ►CModelFrameSemantics | This feature will apply frame semantics to Model objects |
| CCompleteFrameSemantics | This feature will apply frame semantics to all objects |
| CShapeFrameSemantics | |
| CGetBasicJointProperties | This feature retrieves the generalized joint properties such as Degrees Of Freedom (DoF), the transformation matrix from the joint's parent link to this joint and the transformation matrix from this joint to its child link |
| CGetBasicJointState | This feature retrieves the generalized joint states such as position, velocity, acceleration of the joint, applied force to the joint and the transformation matrix from the joint's parent link to this joint's child link based on its current position |
| CGetEngineInfo | This feature retrieves the physics engine name in use |
| CGetJointFromModel | This feature retrieves the joint pointer from the model by specifying model index and joint index/name |
| CGetLinkFromModel | This feature retrieves the link pointer from the model by specifying model index and link index/name |
| CGetModelFromWorld | This feature retrieves the model pointer from the simulation world by specifying world index and model index/name |
| CGetShapeCollisionProperties | This feature retrieves the shape collision properties such as the shape surface friction coefficient and restitution coefficient |
| CGetShapeFrictionPyramidSlipCompliance | This feature retrieves the shape's slip compliance of the first and second friction direction in the friction pyramid model |
| CGetShapeFromLink | This feature retrieves the shape pointer from the link by specifying link index and shape index/name |
| CGetShapeKinematicProperties | This feature retrieves the shape kinematic properties such as the the relative transform from the the link frame to this shape frame |
| CGetWorldFromEngine | This feature retrieves the world pointer using index or name from the physics engine in use |
| CRemoveModelFromWorld | This feature removes a Model entity from the index-specified World |
| CRemoveNestedModelFromModel | This feature removes a nested Model entity from the specified parent Model |
| CSetBasicJointState | This feature sets the generalized joint states such as position, velocity, acceleration of the joint and the applied force to the joint |
| CSetJointEffortLimitsFeature | This feature sets the min and max value of effort of this Joint |
| CSetJointPositionLimitsFeature | This feature sets the min and max generalized position of this Joint |
| CSetJointTransformFromParentFeature | |
| CSetJointTransformToChildFeature | |
| CSetJointVelocityCommandFeature | This feature sets the commanded value of generalized velocity of this Joint |
| CSetJointVelocityLimitsFeature | This feature sets the min and max value of generalized velocity of this Joint |
| CSetMimicConstraintFeature | This feature applies a Mimic constraint to an axis of this Joint. This constraint encodes a linear relationship between the output position of two joint axes. One joint axis is labelled as the leader and the other as the follower. The multiplier, offset, and reference parameters determine the linear relationship according to the following equation: |
| CSetShapeCollisionProperties | This feature sets the Shape collision properties such as the Shape surface friction coefficient and restitution coefficient |
| CSetShapeFrictionPyramidSlipCompliance | This feature sets the Shape's slip compliance of the first and second friction direction in the friction pyramid model |
| CSetShapeKinematicProperties | |
| CSolver | |
| CWorldModelFeature | This feature retrieves a model proxy of a world so that model APIs can be used on the world, e.g., to access a world joint |
| CConstructSdfCollision | |
| CConstructSdfJoint | |
| CConstructSdfLink | |
| CConstructSdfModel | Construct a model entity from an sdf::Model DOM object. This feature is limited to constructing models that have no nested models |
| CConstructSdfNestedModel | Construct nested models. Note this is a partial implementation and the behavior may change once the model composition sdf proposal lands in libSDFormat11 |
| CConstructSdfVisual | |
| CConstructSdfWorld | |
| CFeaturePolicy< _Scalar, _Dim > | FeaturePolicy is a "policy class" used to provide metadata to features about what kind of simulation engine they are going to be used in |
| CFeatureWithConflicts< ConflictingFeatures > | If your feature is known to conflict with any other feature, then you should have your feature class inherit FeatureWithConflicts<...>, and pass it a list of the features that it conflicts with |
| CFeatureWithRequirements< RequiredFeatures > | If your feature is known to require any other features, then you should have your feature class inherit FeatureWithRequirements<...>, and pass it a list of the features that it requires |
| ►CFeatureWithRequirements< BoxShapeCast > | |
| CAttachBoxShapeFeature | This feature constructs a new box shape and attaches the desired pose in the link frame. The pose could be defined to be the box center point or any corner in actual implementation |
| CSetBoxShapeProperties | |
| ►CFeatureWithRequirements< CapsuleShapeCast > | |
| CAttachCapsuleShapeFeature | This feature constructs a new capsule shape and attaches the desired pose in the link frame. The pose could be defined to be the capsule center point in actual implementation |
| CSetCapsuleShapeProperties | This feature sets the CapsuleShape properties such as the capsule radius and length |
| ►CFeatureWithRequirements< ConeShapeCast > | |
| CAttachConeShapeFeature | This feature constructs a new cone shape and attaches the desired pose in the link frame. The pose could be defined to be the cone center point in actual implementation |
| CSetConeShapeProperties | This feature sets the ConeShape properties such as the cone radius and height |
| ►CFeatureWithRequirements< CylinderShapeCast > | |
| CAttachCylinderShapeFeature | This feature constructs a new cylinder shape and attaches the desired pose in the link frame. The pose could be defined to be the cylinder center point in actual implementation |
| CSetCylinderShapeProperties | This feature sets the CylinderShape properties such as the cylinder radius and height |
| ►CFeatureWithRequirements< EllipsoidShapeCast > | |
| CAttachEllipsoidShapeFeature | This feature constructs a new ellipsoid shape and attaches the desired pose in the link frame. The pose could be defined to be the ellipsoid center point in actual implementation |
| CSetEllipsoidShapeProperties | This feature sets the EllipsoidShape properties such as the ellipsoid radii |
| ►CFeatureWithRequirements< FindFreeGroupFeature > | |
| CSetFreeGroupWorldPose | This features sets the FreeGroup pose in world frame. However, while a physics engine with maximal coordinates can provide Link::SetWorldPose and similar functions for setting velocity regardless of the kinematic constraints on that link, this behavior for FreeGroup is not well defined and difficult to implement with generalized coordinates. The FreeGroup::SetWorldPose function should provide an analog to both Link::SetWorldPose and Model::SetWorldPose |
| CSetFreeGroupWorldVelocity | This features sets the FreeGroup linear and angular velocity in world frame |
| ►CFeatureWithRequirements< FindFreeGroupFeature, FrameSemantics > | |
| CFreeGroupFrameSemantics | 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 |
| ►CFeatureWithRequirements< ForwardStep > | |
| CGetContactsFromLastStepFeature | GetContactsFromLastStepFeature is a feature for retrieving the list of contacts generated in the previous simulation step |
| CGetRayIntersectionFromLastStepFeature | GetRayIntersectionFromLastStepFeature is a feature for retrieving the ray intersection generated in the previous simulation step |
| CSetContactPropertiesCallbackFeature | SetContactPropertiesCallbackFeature is a feature for setting the properties of a contact after it is created but before it affects the forward step |
| ►CFeatureWithRequirements< GetLinkBoundingBoxRequiredFeatures > | |
| CGetLinkBoundingBox | This feature retrieves the axis aligned bounding box for the shapes attached to this link in the requested frame. The default frame is the world frame |
| ►CFeatureWithRequirements< GetModelBoundingBoxRequiredFeatures > | |
| CGetModelBoundingBox | This feature retrieves the axis aligned bounding box for the model in the requested frame. The default frame is the world frame |
| ►CFeatureWithRequirements< GetModelFromWorld > | |
| CGetNestedModelFromModel | This feature retrieves the nested model pointer from the parent model by specifying the name or index of the nested model |
| ►CFeatureWithRequirements< GravityRequiredFeatures > | |
| CGravity | Get and set the World's gravity vector in a specified frame |
| ►CFeatureWithRequirements< HeightmapShapeCast > | |
| CAttachHeightmapShapeFeature | Attach a heightmap shape to a link |
| ►CFeatureWithRequirements< JointFrameSemantics > | |
| CGetJointTransmittedWrench | |
| ►CFeatureWithRequirements< LinkFrameSemantics > | |
| CAddLinkExternalForceTorque | |
| ►CFeatureWithRequirements< MeshShapeCast > | |
| CAttachMeshShapeFeature | |
| CSetMeshShapeProperties | |
| ►CFeatureWithRequirements< PlaneShapeCast > | |
| CAttachPlaneShapeFeature | This feature constructs a new plane shape and attaches the desired point, which the plane passes thorugh in the link frame. The default point is at zero coordinate |
| CSetPlaneShapeProperties | |
| ►CFeatureWithRequirements< PrismaticJointCast > | |
| CAttachPrismaticJointFeature | 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 |
| CSetPrismaticJointProperties | 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 |
| ►CFeatureWithRequirements< RevoluteJointCast > | |
| CAttachRevoluteJointFeature | 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 |
| CSetRevoluteJointProperties | 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 |
| ►CFeatureWithRequirements< ShapeFrameSemantics > | |
| CGetShapeBoundingBox | This feature retrieves the shape's axis aligned bounding box in the requested frame. The default frame is the world frame |
| ►CFeatureWithRequirements< SphereShapeCast > | |
| CAttachSphereShapeFeature | This feature constructs a new sphere shape and attaches the desired pose in the link frame. The pose is defined as the sphere center point in actual implementation |
| CSetSphereShapeProperties | |
| CFindExpected< Specification > | This allows us to specify that we are interested in expected data while performing template metaprogramming |
| CFindFeatures< FeaturePolicyT, FeatureListT > | |
| CFindRequired< Specification > | This allows us to specify that we are interested in required data while performing template metaprogramming |
| CForceTorque | |
| CFrameData< Scalar, Dim > | 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: |
| CFrameID | 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 |
| CFreeVector | |
| CFromPolicy< PolicyT > | This struct is used to conveniently convert from a policy to a geometric type. Example usage: |
| CGeneralizedParameters | |
| ►CImplementation | |
| ►CFeature::Implementation< PolicyT > | |
| CAddLinkExternalForceTorque::Implementation< PolicyT > | The implementation API for setting force/torque on a link |
| CAddedMass::Implementation< PolicyT > | |
| CAttachBoxShapeFeature::Implementation< PolicyT > | |
| CAttachCapsuleShapeFeature::Implementation< PolicyT > | |
| CAttachConeShapeFeature::Implementation< PolicyT > | |
| CAttachCylinderShapeFeature::Implementation< PolicyT > | |
| CAttachEllipsoidShapeFeature::Implementation< PolicyT > | |
| CAttachPlaneShapeFeature::Implementation< PolicyT > | |
| CAttachPrismaticJointFeature::Implementation< PolicyT > | |
| CAttachRevoluteJointFeature::Implementation< PolicyT > | |
| CAttachSphereShapeFeature::Implementation< PolicyT > | |
| CCollisionDetector::Implementation< PolicyT > | The implementation API for the collision detector |
| CCollisionFilterMaskFeature::Implementation< PolicyT > | |
| CCollisionPairMaxContacts::Implementation< PolicyT > | The implementation API for getting and setting max contacts |
| CConstructEmptyLinkFeature::Implementation< PolicyT > | |
| CConstructEmptyModelFeature::Implementation< PolicyT > | |
| CConstructEmptyNestedModelFeature::Implementation< PolicyT > | |
| CConstructEmptyWorldFeature::Implementation< PolicyT > | |
| CDetachJointFeature::Implementation< PolicyT > | |
| CForwardStep::Implementation< PolicyT > | |
| CFrameSemantics::Implementation< PolicyT > | This class is inherited by physics plugin classes that want to provide this feature |
| CGetBasicJointProperties::Implementation< PolicyT > | The implementation API for getting basic joint properties |
| CGetBasicJointState::Implementation< PolicyT > | The implementation API for getting basic joint state |
| CGetContactsFromLastStepFeature::Implementation< PolicyT > | |
| CGetEngineInfo::Implementation< PolicyT > | |
| CGetJointFromModel::Implementation< PolicyT > | |
| CGetJointTransmittedWrench::Implementation< PolicyT > | |
| CGetLinkFromModel::Implementation< PolicyT > | |
| CGetModelFromWorld::Implementation< PolicyT > | |
| CGetNestedModelFromModel::Implementation< PolicyT > | |
| CGetRayIntersectionFromLastStepFeature::Implementation< PolicyT > | |
| CGetShapeBoundingBox::Implementation< PolicyT > | |
| CGetShapeCollisionProperties::Implementation< PolicyT > | |
| CGetShapeFrictionPyramidSlipCompliance::Implementation< PolicyT > | |
| CGetShapeFromLink::Implementation< PolicyT > | |
| CGetShapeKinematicProperties::Implementation< PolicyT > | |
| CGetWorldFromEngine::Implementation< PolicyT > | |
| CGravity::Implementation< PolicyT > | The implementation API for the gravity |
| CRemoveModelFromWorld::Implementation< PolicyT > | |
| CRemoveNestedModelFromModel::Implementation< PolicyT > | |
| CSetBasicJointState::Implementation< PolicyT > | The implementation API for setting basic joint state |
| CSetBoxShapeProperties::Implementation< PolicyT > | |
| CSetCapsuleShapeProperties::Implementation< PolicyT > | |
| CSetConeShapeProperties::Implementation< PolicyT > | |
| CSetContactPropertiesCallbackFeature::Implementation< PolicyT > | |
| CSetCylinderShapeProperties::Implementation< PolicyT > | |
| CSetEllipsoidShapeProperties::Implementation< PolicyT > | |
| CSetFreeGroupWorldPose::Implementation< PolicyT > | |
| CSetFreeGroupWorldVelocity::Implementation< PolicyT > | |
| CSetJointEffortLimitsFeature::Implementation< PolicyT > | The implementation API for setting effort limit commands |
| CSetJointPositionLimitsFeature::Implementation< PolicyT > | The implementation API for setting position limit commands |
| CSetJointTransformFromParentFeature::Implementation< PolicyT > | |
| CSetJointTransformToChildFeature::Implementation< PolicyT > | The implementation API for setting the transform to the child |
| CSetJointVelocityCommandFeature::Implementation< PolicyT > | The implementation API for setting joint velocity commands |
| CSetJointVelocityLimitsFeature::Implementation< PolicyT > | The implementation API for setting velocity limit commands |
| CSetMimicConstraintFeature::Implementation< PolicyT > | The implementation API for setting the mimic constraint |
| CSetPlaneShapeProperties::Implementation< PolicyT > | |
| CSetPrismaticJointProperties::Implementation< PolicyT > | |
| CSetRevoluteJointProperties::Implementation< PolicyT > | |
| CSetShapeCollisionProperties::Implementation< PolicyT > | |
| CSetShapeFrictionPyramidSlipCompliance::Implementation< PolicyT > | |
| CSetShapeKinematicProperties::Implementation< PolicyT > | |
| CSetSphereShapeProperties::Implementation< PolicyT > | |
| CSolver::Implementation< PolicyT > | The implementation API for the solver |
| CWorldModelFeature::Implementation< PolicyT > | |
| CAttachHeightmapShapeFeature::Implementation< PolicyT > | |
| CAttachMeshShapeFeature::Implementation< PolicyT > | |
| CSetMeshShapeProperties::Implementation< PolicyT > | |
| CConstructSdfCollision::Implementation< PolicyT > | |
| CConstructSdfJoint::Implementation< PolicyT > | |
| CConstructSdfLink::Implementation< PolicyT > | |
| CConstructSdfModel::Implementation< PolicyT > | |
| CConstructSdfNestedModel::Implementation< PolicyT > | |
| CConstructSdfVisual::Implementation< PolicyT > | |
| CConstructSdfWorld::Implementation< PolicyT > | |
| CFeature::Implementation< Policy > | |
| CCompositeData::InsertResult< Data > | This struct is the return type of the various Insert...<T>() functions. It returns a reference to the data entry for the Data type, and it indicates whether the insertion operation actually occurred |
| ►Cintegral_constant< bool, Specification::template AlwaysRequires< Data >() > [external] | |
| CIsRequiredBy< Data, Specification > | Provides a constexpr field named value whose value is true if and only if Data is required by Specification |
| ►Cintegral_constant< bool, Specification::template Expects< Data >() > [external] | |
| CIsExpectedBy< Data, Specification > | Provides a constexpr field named value whose value is true if and only if Data is expected by Specification |
| ►Cintegral_constant< bool, std::is_const< To >::value > [external] | |
| CConstCompatible< To, const From > | |
| ►CIterateTuple< std::tuple< FeaturesT... > > | |
| ►CFeatureList< GetEngineInfo, GetWorldFromEngine, GetModelFromWorld, GetNestedModelFromModel, GetLinkFromModel, GetJointFromModel, GetShapeFromLink > | |
| CGetEntities | |
| CFeatureList< FeaturesT > | Use a FeatureList to aggregate a list of Features |
| CJointPositions | |
| COperateOnSpecifiedData< Specification, SpecFinder, Operation, Performer > | 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 |
| CPIDValues | |
| CPoint | |
| CGetRayIntersectionFromLastStepFeature::RayIntersectionT< PolicyT > | |
| CReadOptions | ReadOptions provides customization for the ReadRequiredData and ReadExpectedData functions provided by CanReadRequiredData and CanReadExpectedData |
| CRelativeQuantity< Q, Dim, CoordinateSpace > | 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 |
| CRequestEngine< FeaturePolicyT, FeatureListT > | This class provides utilities for inspecting what features are available in a plugin |
| CRequestFeatures< ToFeatureList > | This class can be used to request features from an entity, or identify what features are missing from an entity |
| CServoControlCommands | |
| CSpecifyData< Specifications > | 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: |
| CTimeStep | |
| ►Ctrue_type [external] | |
| CConstCompatible< To, From > | 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 |
| Ctype< T > | This can be used to turn a type into a function argument, which is useful for template metaprogramming |
| CVelocityControlCommands | |
| CWorldPose | |
| CWorldPoses | |
| CWrench< Scalar, Dim > | |
| CWriteOptions | A struct that defines options for writing data to a CompositeData object |
