Namespace List
Here is a list of all namespaces with brief descriptions:
[detail level 12345]
| ▼Ngz [external] | |
| ►Nphysics | |
| ►Nheightmap | |
| ►CAttachHeightmapShapeFeature | Attach a heightmap shape to a link |
| CImplementation | |
| CLink | |
| ►Nmesh | |
| ►CAttachMeshShapeFeature | |
| CImplementation | |
| CLink | |
| ►CSetMeshShapeProperties | |
| CImplementation | |
| CMeshShape | |
| ►Nsdf | |
| ►CConstructSdfCollision | |
| CImplementation | |
| CLink | |
| ►CConstructSdfJoint | |
| CImplementation | |
| CModel | |
| ►CConstructSdfLink | |
| CImplementation | |
| CModel | |
| ►CConstructSdfModel | Construct a model entity from an sdf::Model DOM object. This feature is limited to constructing models that have no nested models |
| CImplementation | |
| CWorld | |
| ►CConstructSdfNestedModel | Construct nested models. Note this is a partial implementation and the behavior may change once the model composition sdf proposal lands in libSDFormat11 |
| CImplementation | |
| CModel | |
| CWorld | |
| ►CConstructSdfVisual | |
| CImplementation | |
| CLink | |
| ►CConstructSdfWorld | |
| CEngine | |
| CImplementation | |
| ►CAddedMass | |
| CImplementation | |
| CLink | |
| ►CAddLinkExternalForceTorque | |
| CImplementation | The implementation API for setting force/torque on a link |
| CLink | The Link API for adding link force/torque |
| CApplyExternalForceTorques | |
| CApplyGeneralizedForces | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| ►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 |
| CImplementation | |
| CLink | |
| CCanReadExpectedData | |
| CCanReadRequiredData | 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 | |
| CCanWriteRequiredData | 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) |
| ►CCategoryFilterMaskFeature | |
| CImplementation | |
| CShape | |
| 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 |
| ►CCollisionDetector | |
| CImplementation | The implementation API for the collision detector |
| CWorld | The World API for setting the collision detector |
| ►CCollisionFilterMaskFeature | |
| CImplementation | |
| CShape | |
| ►CCollisionPairMaxContacts | |
| CImplementation | The implementation API for getting and setting max contacts |
| CWorld | The World API for getting and setting the maximum number of contacts between two entities |
| CCompleteFrameSemantics | This feature will apply frame semantics to all objects |
| ►CCompositeData | Allows arbitrary data structures to be composed together, copied, and moved with type erasure |
| CDataStatus | Struct that describes the status of data |
| CInsertResult | 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 |
| CConstCompatible | 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 |
| CConstCompatible< To, const From > | |
| ►CConstructEmptyLinkFeature | This feature constructs an empty link and returns its pointer from the given model |
| CImplementation | |
| CModel | |
| ►CConstructEmptyModelFeature | [ConstructEmptyWorld] |
| CImplementation | |
| CWorld | |
| ►CConstructEmptyNestedModelFeature | This feature constructs an empty nested model and returns its pointer from the given world |
| CImplementation | |
| CModel | |
| ►CConstructEmptyWorldFeature | This feature constructs an empty world and returns its pointer from the current physics engine in use |
| CEngine | |
| CImplementation | |
| CContacts | |
| 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 |
| ►CDetachJointFeature | |
| CImplementation | |
| CJoint | |
| CEmpty | Useful as a blank placeholder in template metaprogramming |
| CEntity | 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 |
| CEntityPtr | |
| 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) |
| ►CFeature | This class defines the concept of a Feature. It should be inherited by classes that define some plugin feature |
| CEngine | Placeholder class for the Engine API. Every Engine feature MUST inherit this class |
| CImplementation | |
| CJoint | Placeholder class in case a Feature does not define its own Joint API |
| CLink | Placeholder class in case a Feature does not define its own Link API |
| CModel | Placeholder class in case a Feature does not define its own Model API |
| CShape | Placeholder class in case a Feature does not define its own Shape API |
| CWorld | Placeholder class in case a Feature does not define its own World API |
| CFeatureList | Use a FeatureList to aggregate a list of Features |
| CFeaturePolicy | 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 | 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 | 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 |
| CFindExpected | This allows us to specify that we are interested in expected data while performing template metaprogramming |
| CFindFeatures | |
| CFindRequired | This allows us to specify that we are interested in required data while performing template metaprogramming |
| CForceTorque | |
| ►CForwardStep | ForwardStep is a feature that allows a simulation of a world to take one step forward in time |
| CImplementation | |
| CWorld | |
| CFrameData | 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 |
| ►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 |
| CEngine | This class defines the engine interface that provides the FrameSemantics feature |
| CFrame | Base class for the API of a Frame. This will be inherited by any objects that are able to express Frame Semantics |
| CImplementation | This class is inherited by physics plugin classes that want to provide this feature |
| 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 |
| CFreeVector | |
| CFromPolicy | This struct is used to conveniently convert from a policy to a geometric type. Example usage: |
| CGeneralizedParameters | |
| ►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 |
| CImplementation | The implementation API for getting basic joint properties |
| CJoint | The Joint API for getting basic joint properties |
| ►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 |
| CImplementation | The implementation API for getting basic joint state |
| CJoint | The Joint API for getting basic joint state |
| ►CGetBatchRayIntersectionFromLastStepFeature | GetBatchRayIntersectionFromLastStepFeature is a feature for retrieving multiple ray intersections generated in the previous simulation step in a single call |
| CImplementation | |
| CRayT | |
| CWorld | |
| ►CGetContactsFromLastStepFeature | GetContactsFromLastStepFeature is a feature for retrieving the list of contacts generated in the previous simulation step |
| CExtraContactDataT | |
| ►CImplementation | |
| CContactInternal | |
| ►CWorld | |
| CContactPoint | |
| ►CGetEngineInfo | This feature retrieves the physics engine name in use |
| CEngine | |
| CImplementation | |
| CGetEntities | |
| ►CGetJointFromModel | This feature retrieves the joint pointer from the model by specifying model index and joint index/name |
| CImplementation | |
| CJoint | |
| CModel | |
| ►CGetJointTransmittedWrench | |
| CImplementation | |
| CJoint | |
| ►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 |
| CLink | |
| ►CGetLinkFromModel | This feature retrieves the link pointer from the model by specifying model index and link index/name |
| CImplementation | |
| CLink | |
| CModel | |
| ►CGetModelBoundingBox | This feature retrieves the axis aligned bounding box for the model in the requested frame. The default frame is the world frame |
| CModel | |
| ►CGetModelFromWorld | This feature retrieves the model pointer from the simulation world by specifying world index and model index/name |
| CImplementation | |
| CModel | |
| CWorld | |
| ►CGetNestedModelFromModel | This feature retrieves the nested model pointer from the parent model by specifying the name or index of the nested model |
| CImplementation | |
| CModel | |
| ►CGetRayIntersectionFromLastStepFeature | GetRayIntersectionFromLastStepFeature is a feature for retrieving the ray intersection generated in the previous simulation step |
| CImplementation | |
| CRayIntersectionT | |
| CWorld | |
| ►CGetShapeBoundingBox | This feature retrieves the shape's axis aligned bounding box in the requested frame. The default frame is the world frame |
| CImplementation | |
| CShape | |
| ►CGetShapeCollisionProperties | This feature retrieves the shape collision properties such as the shape surface friction coefficient and restitution coefficient |
| CImplementation | |
| CShape | |
| ►CGetShapeFrictionPyramidSlipCompliance | This feature retrieves the shape's slip compliance of the first and second friction direction in the friction pyramid model |
| CImplementation | |
| CShape | |
| ►CGetShapeFromLink | This feature retrieves the shape pointer from the link by specifying link index and shape index/name |
| CImplementation | |
| CLink | |
| CShape | |
| ►CGetShapeKinematicProperties | This feature retrieves the shape kinematic properties such as the the relative transform from the the link frame to this shape frame |
| CImplementation | |
| CShape | |
| ►CGetWorldFromEngine | This feature retrieves the world pointer using index or name from the physics engine in use |
| CEngine | |
| CImplementation | |
| CWorld | |
| ►CGravity | Get and set the World's gravity vector in a specified frame |
| CImplementation | The implementation API for the gravity |
| CWorld | The World API for getting and setting the gravity vector |
| ►CGravityEnabled | Feature for getting and setting whether gravity affects a link or a model |
| CImplementation | The implementation API for gravity mode |
| CLink | The Link API for getting and setting gravity mode |
| CModel | The Model API for getting and setting gravity mode |
| CIsExpectedBy | Provides a constexpr field named value whose value is true if and only if Data is expected by Specification |
| CIsRequiredBy | Provides a constexpr field named value whose value is true if and only if Data is required by Specification |
| CJointFrameSemantics | This feature will apply frame semantics to Joint objects |
| CJointPositions | |
| ►CKinematicLink | |
| CImplementation | |
| CLink | The Link API for setting link to be kinematic |
| CLinkFrameSemantics | This feature will apply frame semantics to Link objects |
| ►CModelCollisionEnabled | Feature for enabling and disabling collisions on a model. When collisions are disabled, the model's links will not collide with other entities in the world |
| CImplementation | The implementation API for model collision enabled state |
| CModel | The Model API for enabling and disabling collisions |
| CModelFrameSemantics | This feature will apply frame semantics to Model objects |
| ►CModelStaticState | Feature for getting and setting the static state of a model. A static model has all its bodies fixed in place (infinite mass) |
| CImplementation | The implementation API for model static state |
| CModel | The Model API for getting and setting static state |
| COperateOnSpecifiedData | 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 | |
| CReadOptions | ReadOptions provides customization for the ReadRequiredData and ReadExpectedData functions provided by CanReadRequiredData and CanReadExpectedData |
| CRelativeQuantity | 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 |
| ►CRemoveModelFromWorld | This feature removes a Model entity from the index-specified World |
| CImplementation | |
| CModel | |
| CWorld | |
| ►CRemoveNestedModelFromModel | This feature removes a nested Model entity from the specified parent Model |
| CImplementation | |
| CModel | |
| CRequestEngine | This class provides utilities for inspecting what features are available in a plugin |
| CRequestFeatures | This class can be used to request features from an entity, or identify what features are missing from an entity |
| 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 |
| CServoControlCommands | |
| ►CSetBasicJointState | This feature sets the generalized joint states such as position, velocity, acceleration of the joint and the applied force to the joint |
| CImplementation | The implementation API for setting basic joint state |
| CJoint | The Joint API for setting basic joint state |
| ►CSetBoxShapeProperties | |
| CBoxShape | |
| CImplementation | |
| ►CSetCapsuleShapeProperties | This feature sets the CapsuleShape properties such as the capsule radius and length |
| CCapsuleShape | |
| CImplementation | |
| ►CSetConeShapeProperties | This feature sets the ConeShape properties such as the cone radius and height |
| CConeShape | |
| CImplementation | |
| ►CSetContactPropertiesCallbackFeature | SetContactPropertiesCallbackFeature is a feature for setting the properties of a contact after it is created but before it affects the forward step |
| CContactSurfaceParams | 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 |
| CImplementation | |
| CWorld | |
| ►CSetCylinderShapeProperties | This feature sets the CylinderShape properties such as the cylinder radius and height |
| CCylinderShape | |
| CImplementation | |
| ►CSetEllipsoidShapeProperties | This feature sets the EllipsoidShape properties such as the ellipsoid radii |
| CEllipsoidShape | |
| CImplementation | |
| ►CSetFixedJointWeldChildToParentFeature | |
| CImplementation | |
| CJoint | The Joint API for setting whether to weld a fixed joint's child link to the parent link |
| ►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 |
| CFreeGroup | 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 |
| CImplementation | |
| ►CSetFreeGroupWorldVelocity | This features sets the FreeGroup linear and angular velocity in world frame |
| CFreeGroup | 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 |
| CImplementation | |
| ►CSetJointDampingCoefficientFeature | This feature sets the damping coefficient for this Joint |
| CImplementation | The implementation API for setting joint damping coefficient |
| CJoint | The Joint API for setting damping coefficient of a joint |
| ►CSetJointEffortLimitsFeature | This feature sets the min and max value of effort of this Joint |
| CImplementation | The implementation API for setting effort limit commands |
| CJoint | The Joint API for setting effort limits of a joint. These limits are applied to joints controlled via positional, velocity or effort commands |
| ►CSetJointFrictionFeature | This feature sets friction of this Joint. Refer to //joint/axis/dynamics/friction SDF tag |
| CImplementation | The implementation API for setting joint friction |
| CJoint | The Joint API for setting friction of a joint |
| ►CSetJointPositionLimitsFeature | This feature sets the min and max generalized position of this Joint |
| CImplementation | The implementation API for setting position limit commands |
| CJoint | The Joint API for setting position limits of a joint |
| ►CSetJointSpringReferenceFeature | This feature sets the spring reference position of this joint |
| CImplementation | The implementation API for setting joint rest position |
| CJoint | The Joint API for setting spring rest position of a joint |
| ►CSetJointSpringStiffnessFeature | This feature sets the spring stiffness of this Joint |
| CImplementation | The implementation API for setting joint spring stiffness |
| CJoint | The Joint API for setting spring stiffness of a Joint |
| ►CSetJointTransformFromParentFeature | |
| CImplementation | |
| CJoint | The Joint API for setting the transform from the joint's parent |
| ►CSetJointTransformToChildFeature | |
| CImplementation | The implementation API for setting the transform to the child |
| CJoint | The Joint API for setting the transform to the joint's child |
| ►CSetJointVelocityCommandFeature | This feature sets the commanded value of generalized velocity of this Joint |
| CImplementation | The implementation API for setting joint velocity commands |
| CJoint | 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 | This feature sets the min and max value of generalized velocity of this Joint |
| CImplementation | The implementation API for setting velocity limit commands |
| CJoint | The Joint API for setting velocity limits of a joint. These limits apply to joints commanded via velocity or positional commands |
| ►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: |
| CImplementation | The implementation API for setting the mimic constraint |
| CJoint | |
| ►CSetPlaneShapeProperties | |
| CImplementation | |
| CPlaneShape | |
| ►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 |
| CImplementation | |
| CPrismaticJoint | The API for setting basic prismatic joint properties |
| ►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 |
| CImplementation | |
| CRevoluteJoint | The API for setting basic revolute joint properties |
| ►CSetShapeCollisionProperties | This feature sets the Shape collision properties such as the Shape surface friction coefficient and restitution coefficient |
| CImplementation | |
| CShape | |
| ►CSetShapeFrictionPyramidSlipCompliance | This feature sets the Shape's slip compliance of the first and second friction direction in the friction pyramid model |
| CImplementation | |
| CShape | |
| ►CSetShapeKinematicProperties | |
| CImplementation | |
| CShape | |
| ►CSetSphereShapeProperties | |
| CImplementation | |
| CSphereShape | |
| CShapeFrameSemantics | |
| ►CSolver | |
| CImplementation | The implementation API for the solver |
| CWorld | The World API for setting the solver |
| CSpecifyData | 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 | |
| Ctype | This can be used to turn a type into a function argument, which is useful for template metaprogramming |
| CTypeList | A minimal variadic template container for types. This is used instead of std::tuple for intermediate template metaprogramming to drastically reduce compiler memory and instantiation times |
| CTypeListCat | Concatenate multiple TypeLists into a single TypeList |
| CTypeListCat< L1, L2, L3, Rest... > | |
| CTypeListCat< TypeList< T1... >, TypeList< T2... > > | |
| CTypeListCat< TypeList< Ts... > > | |
| CTypeListCat<> | |
| CVelocityControlCommands | |
| ►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 |
| CImplementation | |
| CWorld | |
| CWorldPose | |
| CWorldPoses | |
| CWrench | |
| CWriteOptions | A struct that defines options for writing data to a CompositeData object |
| Nstd | STL namespace |