Gazebo Physics

API Reference

2.6.2
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 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)
 CCompositeDataAllows arbitrary data structures to be composed together, copied, and moved with type erasure
 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::DataStatusStruct that describes the status of data
 CDataStatusMaskThis 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
 CEmptyUseful 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
 CEntity< Policy, FeaturesT >
 CEntityPtr< EntityT >
 CExpectData
 CGetContactsFromLastStepFeature::ExtraContactDataT< PolicyT >
 CFeatureThis class defines the concept of a Feature. It should be inherited by classes that define some plugin feature
 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 >
 CFeatureWithRequirements< CylinderShapeCast >
 CFeatureWithRequirements< FindFreeGroupFeature >
 CFeatureWithRequirements< FindFreeGroupFeature, FrameSemantics >
 CFeatureWithRequirements< ForwardStep >
 CFeatureWithRequirements< GetLinkBoundingBoxRequiredFeatures >
 CFeatureWithRequirements< GetModelBoundingBoxRequiredFeatures >
 CFeatureWithRequirements< LinkFrameSemantics >
 CFeatureWithRequirements< MeshShapeCast >
 CFeatureWithRequirements< PlaneShapeCast >
 CFeatureWithRequirements< PrismaticJointCast >
 CFeatureWithRequirements< RevoluteJointCast >
 CFeatureWithRequirements< ShapeFrameSemantics >
 CFeatureWithRequirements< SphereShapeCast >
 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
 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
 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:
 CFrameIDContainer 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
 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]
 Cintegral_constant< bool, Specification::template Expects< Data >() > [external]
 Cintegral_constant< bool, std::is_const< To >::value > [external]
 CIterateTuple< std::tuple< FeaturesT... > >
 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
 CReadOptionsReadOptions 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]
 Ctype< T >This can be used to turn a type into a function argument, which is useful for template metaprogramming
 CVelocityControlCommands
 CWorldPose
 CWorldPoses
 CWriteOptionsA struct that defines options for writing data to a CompositeData object