Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12345]
| ▼Nignition | |
| ►Nphysics | |
| ►Ndartsim | |
| ►CRetrieveWorld | |
| CImplementation | |
| CWorld | |
| ►Nmesh | |
| ►CAttachMeshShapeFeature | |
| CImplementation | |
| CLink | |
| ►CSetMeshShapeProperties | |
| CImplementation | |
| CMeshShape | |
| ►Nsdf | |
| ►CConstructSdfCollision | |
| CImplementation | |
| CLink | |
| ►CConstructSdfJoint | |
| CImplementation | |
| CModel | |
| ►CConstructSdfLink | |
| CImplementation | |
| CModel | |
| ►CConstructSdfModel | |
| CImplementation | |
| CWorld | |
| ►CConstructSdfVisual | |
| CImplementation | |
| CLink | |
| ►CConstructSdfWorld | |
| CEngine | |
| CImplementation | |
| ►CAddLinkExternalForceTorque | |
| CImplementation | The implementation API for setting force/torque on a link |
| CLink | The Link API for adding link force/torque |
| CApplyExternalForceTorques | |
| CApplyGeneralizedForces | |
| ►CAttachBoxShapeFeature | |
| CImplementation | |
| CLink | |
| ►CAttachCylinderShapeFeature | |
| 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 | |
| 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) |
| 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 | |
| CImplementation | |
| CModel | |
| ►CConstructEmptyModelFeature | |
| CImplementation | |
| CWorld | |
| ►CConstructEmptyWorldFeature | |
| 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 |
| CEmpty | Useful as a blank placeholder in template metaprogramming |
| CEngine | |
| 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 |
| CFeatureWithRequirements | The FeatureWithRequirements class simply wraps up its required features in a FeatureList and then sets the RequiredFeatures type |
| 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 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 |
| 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 | |
| CImplementation | The implementation API for getting basic joint properties |
| CJoint | The Joint API for getting basic joint properties |
| ►CGetBasicJointState | |
| CImplementation | The implementation API for getting basic joint state |
| CJoint | The Joint API for getting basic joint state |
| ►CGetContactsFromLastStepFeature | GetContactsFromLastStepFeature is a feature for retrieving the list of contacts generated in the previous simulation step |
| ►CImplementation | |
| CContactInternal | |
| ►CWorld | |
| CContactPoint | |
| ►CGetEngineInfo | |
| CEngine | |
| CImplementation | |
| ►CGetJointFromModel | |
| CImplementation | |
| CJoint | |
| CModel | |
| ►CGetLinkFromModel | |
| CImplementation | |
| CLink | |
| CModel | |
| ►CGetModelFromWorld | |
| CImplementation | |
| CModel | |
| CWorld | |
| ►CGetShapeBoundingBox | |
| CImplementation | |
| CShape | |
| ►CGetShapeCollisionProperties | |
| CImplementation | |
| CShape | |
| ►CGetShapeFromLink | |
| CImplementation | |
| CLink | |
| CShape | |
| ►CGetShapeKinematicProperties | |
| CImplementation | |
| CShape | |
| ►CGetWorldFromEngine | |
| CEngine | |
| CImplementation | |
| CWorld | |
| CIdentity | 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 |
| 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 |
| CJoint | |
| CJointFrameSemantics | This feature will apply frame semantics to Joint objects |
| CJointPositions | |
| CLink | |
| CLinkFrameSemantics | This feature will apply frame semantics to Link objects |
| CModel | |
| CModelFrameSemantics | This feature will apply frame semantics to Model objects |
| 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 | |
| CImplementation | |
| CModel | |
| CWorld | |
| CRequestEngine | This class provides utilities for inspecting what features are available in a plugin |
| 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 | |
| CImplementation | The implementation API for setting basic joint state |
| CJoint | The Joint API for setting basic joint state |
| ►CSetBoxShapeProperties | |
| CBoxShape | |
| CImplementation | |
| ►CSetCylinderShapeProperties | |
| CCylinderShape | |
| CImplementation | |
| ►CSetFreeGroupWorldPose | |
| CFreeGroup | |
| CImplementation | |
| ►CSetFreeGroupWorldVelocity | |
| CFreeGroup | |
| CImplementation | |
| ►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 |
| ►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 | |
| CImplementation | |
| CShape | |
| ►CSetShapeKinematicProperties | |
| CImplementation | |
| CShape | |
| ►CSetSphereShapeProperties | |
| CImplementation | |
| CSphereShape | |
| CShape | |
| CShapeFrameSemantics | |
| 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 |
| CVelocityControlCommands | |
| CWorld | |
| CWorldPose | |
| CWorldPoses | |
| CWriteOptions | A struct that defines options for writing data to a CompositeData object |
| ▼Nstd | STL namespace |
| Chash< EntityPtr< EntityT > > | Template specialization that provides a hash function for EntityPtr so that it can easily be used in STL objects like std::unordered_set and std::unordered_map |