| ►Nagx | The agx namespace contains the dynamics/math part of the AGX Dynamics API |
| ►Ndetail | |
| CContactForceFilterParticipant | |
| CParticleEventListener | Particle EventListener that can be inherited and overridden in order to listen to particle events |
| CParticleGeometryContactInformation | |
| CParticleInformation | |
| CParticlePairContactInformation | |
| ►NPhysics | |
| ►NGeometry | |
| CBoxModel | Abstract description of the data attributes for the Physics.Geometry.Box entity |
| CBoxPtr | Pointer to a entity instance of type Physics.Geometry.Box |
| CCapsuleModel | Abstract description of the data attributes for the Physics.Geometry.Capsule entity |
| CCapsulePtr | Pointer to a entity instance of type Physics.Geometry.Capsule |
| CConeModel | Abstract description of the data attributes for the Physics.Geometry.Cone entity |
| CConePtr | Pointer to a entity instance of type Physics.Geometry.Cone |
| CConvexModel | Abstract description of the data attributes for the Physics.Geometry.Convex entity |
| CConvexPtr | Pointer to a entity instance of type Physics.Geometry.Convex |
| CCylinderModel | Abstract description of the data attributes for the Physics.Geometry.Cylinder entity |
| CCylinderPtr | Pointer to a entity instance of type Physics.Geometry.Cylinder |
| CHeightFieldModel | Abstract description of the data attributes for the Physics.Geometry.HeightField entity |
| CHeightFieldPtr | Pointer to a entity instance of type Physics.Geometry.HeightField |
| CHollowConeModel | Abstract description of the data attributes for the Physics.Geometry.HollowCone entity |
| CHollowConePtr | Pointer to a entity instance of type Physics.Geometry.HollowCone |
| CHollowCylinderModel | Abstract description of the data attributes for the Physics.Geometry.HollowCylinder entity |
| CHollowCylinderPtr | Pointer to a entity instance of type Physics.Geometry.HollowCylinder |
| CLineModel | Abstract description of the data attributes for the Physics.Geometry.Line entity |
| CLinePtr | Pointer to a entity instance of type Physics.Geometry.Line |
| CMeshModel | Abstract description of the data attributes for the Physics.Geometry.Mesh entity |
| CMeshPtr | Pointer to a entity instance of type Physics.Geometry.Mesh |
| CPlaneModel | Abstract description of the data attributes for the Physics.Geometry.Plane entity |
| CPlanePtr | Pointer to a entity instance of type Physics.Geometry.Plane |
| CRenderBoxModel | Abstract description of the data attributes for the Physics.Geometry.RenderBox entity |
| CRenderBoxPtr | Pointer to a entity instance of type Physics.Geometry.RenderBox |
| CShapeGroupModel | Abstract description of the data attributes for the Physics.Geometry.ShapeGroup entity |
| CShapeGroupPtr | Pointer to a entity instance of type Physics.Geometry.ShapeGroup |
| CShapeModel | Abstract description of the data attributes for the Physics.Geometry.Shape entity |
| CShapePtr | Pointer to a entity instance of type Physics.Geometry.Shape |
| CSphereModel | Abstract description of the data attributes for the Physics.Geometry.Sphere entity |
| CSpherePtr | Pointer to a entity instance of type Physics.Geometry.Sphere |
| CTriangleModel | Abstract description of the data attributes for the Physics.Geometry.Triangle entity |
| CTrianglePtr | Pointer to a entity instance of type Physics.Geometry.Triangle |
| CTrimeshModel | Abstract description of the data attributes for the Physics.Geometry.Trimesh entity |
| CTrimeshPtr | Pointer to a entity instance of type Physics.Geometry.Trimesh |
| CWireShapeModel | Abstract description of the data attributes for the Physics.Geometry.WireShape entity |
| CWireShapePtr | Pointer to a entity instance of type Physics.Geometry.WireShape |
| ►NGranularBody | |
| CCachedGranularContactModel | Abstract description of the data attributes for the Physics.GranularBody.CachedGranularContact entity |
| CCachedGranularContactPtr | Pointer to a entity instance of type Physics.GranularBody.CachedGranularContact |
| CContactConstraint32Model | Abstract description of the data attributes for the Physics.GranularBody.ContactConstraint32 entity |
| CContactConstraint32Ptr | Pointer to a entity instance of type Physics.GranularBody.ContactConstraint32 |
| CContactConstraintModel | Abstract description of the data attributes for the Physics.GranularBody.ContactConstraint entity |
| CContactConstraintPtr | Pointer to a entity instance of type Physics.GranularBody.ContactConstraint |
| CContactLambda | |
| ►NHierarchicalGrid | |
| CCell2DModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.Cell2D entity |
| CCell2DPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.Cell2D |
| CCellModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.Cell entity |
| CCellPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.Cell |
| CCollisionObject2DModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.CollisionObject2D entity |
| CCollisionObject2DPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.CollisionObject2D |
| CCollisionObjectModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.CollisionObject entity |
| CCollisionObjectPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.CollisionObject |
| CContactZone_CornerModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.ContactZone_Corner entity |
| CContactZone_CornerPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.ContactZone_Corner |
| CContactZone_EdgeModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.ContactZone_Edge entity |
| CContactZone_EdgePtr | Pointer to a entity instance of type Physics.HierarchicalGrid.ContactZone_Edge |
| CContactZone_FaceModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.ContactZone_Face entity |
| CContactZone_FacePtr | Pointer to a entity instance of type Physics.HierarchicalGrid.ContactZone_Face |
| CContactZone_InternalModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.ContactZone_Internal entity |
| CContactZone_InternalPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.ContactZone_Internal |
| CContactZoneDependencyModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.ContactZoneDependency entity |
| CContactZoneDependencyPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.ContactZoneDependency |
| CContactZoneManager | |
| CContactZoneModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.ContactZone entity |
| CContactZonePtr | Pointer to a entity instance of type Physics.HierarchicalGrid.ContactZone |
| CCornerZoneModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.CornerZone entity |
| CCornerZonePtr | Pointer to a entity instance of type Physics.HierarchicalGrid.CornerZone |
| CGridOverlapModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.GridOverlap entity |
| CGridOverlapPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.GridOverlap |
| CGridTier2DModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.GridTier2D entity |
| CGridTier2DPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.GridTier2D |
| CGridTierModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.GridTier entity |
| CGridTierPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.GridTier |
| CNeighborCellPath | |
| COrientedGeometryBoundModel | Abstract description of the data attributes for the Physics.HierarchicalGrid.OrientedGeometryBound entity |
| COrientedGeometryBoundPtr | Pointer to a entity instance of type Physics.HierarchicalGrid.OrientedGeometryBound |
| CSolveBodyManager | |
| ►NParticle | |
| CContactConstraintModel | Abstract description of the data attributes for the Physics.Particle.ContactConstraint entity |
| CContactConstraintPtr | Pointer to a entity instance of type Physics.Particle.ContactConstraint |
| CContactConstraintRow32Model | Abstract description of the data attributes for the Physics.Particle.ContactConstraintRow32 entity |
| CContactConstraintRow32Ptr | Pointer to a entity instance of type Physics.Particle.ContactConstraintRow32 |
| CContactConstraintRowModel | Abstract description of the data attributes for the Physics.Particle.ContactConstraintRow entity |
| CContactConstraintRowPtr | Pointer to a entity instance of type Physics.Particle.ContactConstraintRow |
| CParticleBodyContactConstraintModel | Abstract description of the data attributes for the Physics.Particle.ParticleBodyContactConstraint entity |
| CParticleBodyContactConstraintPtr | Pointer to a entity instance of type Physics.Particle.ParticleBodyContactConstraint |
| CBinaryConstraintModel | Abstract description of the data attributes for the Physics.BinaryConstraint entity |
| CBinaryConstraintPtr | Pointer to a entity instance of type Physics.BinaryConstraint |
| CBodyContactModel | Abstract description of the data attributes for the Physics.BodyContact entity |
| CBodyContactPtr | Pointer to a entity instance of type Physics.BodyContact |
| CBroadPhasePairModel | Abstract description of the data attributes for the Physics.BroadPhasePair entity |
| CBroadPhasePairPtr | Pointer to a entity instance of type Physics.BroadPhasePair |
| CBulkMaterialModel | Abstract description of the data attributes for the Physics.BulkMaterial entity |
| CBulkMaterialPtr | Pointer to a entity instance of type Physics.BulkMaterial |
| CCollisionGroupModel | Abstract description of the data attributes for the Physics.CollisionGroup entity |
| CCollisionGroupPtr | Pointer to a entity instance of type Physics.CollisionGroup |
| CCollisionGroupSetModel | Abstract description of the data attributes for the Physics.CollisionGroupSet entity |
| CCollisionGroupSetPtr | Pointer to a entity instance of type Physics.CollisionGroupSet |
| CConstraintBaseModel | Abstract description of the data attributes for the Physics.ConstraintBase entity |
| CConstraintBasePtr | Pointer to a entity instance of type Physics.ConstraintBase |
| CConstraintForcesModel | Abstract description of the data attributes for the Physics.ConstraintForces entity |
| CConstraintForcesPtr | Pointer to a entity instance of type Physics.ConstraintForces |
| CConstraintRowModel | Abstract description of the data attributes for the Physics.ConstraintRow entity |
| CConstraintRowPtr | Pointer to a entity instance of type Physics.ConstraintRow |
| CContactConstraintModel | Abstract description of the data attributes for the Physics.ContactConstraint entity |
| CContactConstraintPtr | Pointer to a entity instance of type Physics.ContactConstraint |
| CContactMaterialModel | Abstract description of the data attributes for the Physics.ContactMaterial entity |
| CContactMaterialPtr | Pointer to a entity instance of type Physics.ContactMaterial |
| CContactModel | Abstract description of the data attributes for the Physics.Contact entity |
| CContactPointModel | Abstract description of the data attributes for the Physics.ContactPoint entity |
| CContactPointPtr | Pointer to a entity instance of type Physics.ContactPoint |
| CContactPtr | Pointer to a entity instance of type Physics.Contact |
| CEmitterModel | Abstract description of the data attributes for the Physics.Emitter entity |
| CEmitterPtr | Pointer to a entity instance of type Physics.Emitter |
| CFrameModel | Abstract description of the data attributes for the Physics.Frame entity |
| CFramePtr | Pointer to a entity instance of type Physics.Frame |
| CGeometryContactModel | Abstract description of the data attributes for the Physics.GeometryContact entity |
| CGeometryContactPtr | A geometry contact hold contact information between two geometries |
| CGeometryModel | Abstract description of the data attributes for the Physics.Geometry entity |
| CGeometryPairModel | Abstract description of the data attributes for the Physics.GeometryPair entity |
| CGeometryPairPtr | Pointer to a entity instance of type Physics.GeometryPair |
| CGeometryParticleContactListModel | Abstract description of the data attributes for the Physics.GeometryParticleContactList entity |
| CGeometryParticleContactListPtr | Pointer to a entity instance of type Physics.GeometryParticleContactList |
| CGeometryPtr | Pointer to a entity instance of type Physics.Geometry |
| CGranularBodyModel | Abstract description of the data attributes for the Physics.GranularBody entity |
| CGranularBodyPtr | Pointer to a entity instance of type Physics.GranularBody |
| CGranularBodySystem | |
| CGraphNodeModel | Abstract description of the data attributes for the Physics.GraphNode entity |
| CGraphNodePtr | Pointer to a entity instance of type Physics.GraphNode |
| CInteractionGroupModel | Abstract description of the data attributes for the Physics.InteractionGroup entity |
| CInteractionGroupPtr | Pointer to a entity instance of type Physics.InteractionGroup |
| CInteractionModel | Abstract description of the data attributes for the Physics.Interaction entity |
| CInteractionPtr | Pointer to a entity instance of type Physics.Interaction |
| CManyBodyConstraintModel | Abstract description of the data attributes for the Physics.ManyBodyConstraint entity |
| CManyBodyConstraintPtr | Pointer to a entity instance of type Physics.ManyBodyConstraint |
| CMaterialModel | Abstract description of the data attributes for the Physics.Material entity |
| CMaterialPtr | Pointer to a entity instance of type Physics.Material |
| CParticleGeometryContactModel | Abstract description of the data attributes for the Physics.ParticleGeometryContact entity |
| CParticleGeometryContactPtr | Pointer to a entity instance of type Physics.ParticleGeometryContact |
| CParticleModel | Abstract description of the data attributes for the Physics.Particle entity |
| CParticlePairContactModel | Abstract description of the data attributes for the Physics.ParticlePairContact entity |
| CParticlePairContactPtr | Pointer to a entity instance of type Physics.ParticlePairContact |
| CParticlePtr | Pointer to a entity instance of type Physics.Particle |
| CRigidBodyModel | Abstract description of the data attributes for the Physics.RigidBody entity |
| CRigidBodyPtr | Pointer to a entity instance of type Physics.RigidBody |
| CSolveBody32Model | Abstract description of the data attributes for the Physics.SolveBody32 entity |
| CSolveBody32Ptr | Pointer to a entity instance of type Physics.SolveBody32 |
| CSolveBodyModel | Abstract description of the data attributes for the Physics.SolveBody entity |
| CSolveBodyPtr | Pointer to a entity instance of type Physics.SolveBody |
| CSolveGroupModel | Abstract description of the data attributes for the Physics.SolveGroup entity |
| CSolveGroupPtr | Pointer to a entity instance of type Physics.SolveGroup |
| CSolveIslandModel | Abstract description of the data attributes for the Physics.SolveIsland entity |
| CSolveIslandPtr | Pointer to a entity instance of type Physics.SolveIsland |
| CSolveMaterial32Model | Abstract description of the data attributes for the Physics.SolveMaterial32 entity |
| CSolveMaterial32Ptr | Pointer to a entity instance of type Physics.SolveMaterial32 |
| CSolveMaterialModel | Abstract description of the data attributes for the Physics.SolveMaterial entity |
| CSolveMaterialPtr | Pointer to a entity instance of type Physics.SolveMaterial |
| CSolveParticleModel | Abstract description of the data attributes for the Physics.SolveParticle entity |
| CSolveParticlePtr | Pointer to a entity instance of type Physics.SolveParticle |
| CStrongInteractionModel | Abstract description of the data attributes for the Physics.StrongInteraction entity |
| CStrongInteractionPtr | Pointer to a entity instance of type Physics.StrongInteraction |
| CSurfaceMaterialModel | Abstract description of the data attributes for the Physics.SurfaceMaterial entity |
| CSurfaceMaterialPtr | Pointer to a entity instance of type Physics.SurfaceMaterial |
| CWarmStartingDataModel | Abstract description of the data attributes for the Physics.WarmStartingData entity |
| CWarmStartingDataPtr | Pointer to a entity instance of type Physics.WarmStartingData |
| CWireMaterialModel | Abstract description of the data attributes for the Physics.WireMaterial entity |
| CWireMaterialPtr | Pointer to a entity instance of type Physics.WireMaterial |
| CAbstractMemoryPool | |
| ►CAddedMassInteraction | Interface to write added mass matrices for one or two rigid bodies |
| CMatrix6x6 | 6x6 matrix class with blockwise interface to get or set 3x3 matrices: [ M(0, 0) M(0, 1) ] [ M(1, 0) M(1, 1) ] |
| CRigidBodyStorage | Class containing a rigid body and the 6x6 matrix to be written in the diagonal of the system matrix |
| CAddedMassInteractionHandler | Class containing and handling a global view of several objects interacting trough strong added mass interactions |
| CAffineMatrix4x4T | Matrix class for rigid transformations (translation, rotation) |
| CAgXString | |
| CAlignedAllocator | Aligned allocator |
| CAllocator | Templated allocator |
| CAnalysisBox | Class that can be used to extract data from elements in a simulation within a specified bound |
| CAngle | Constraint angle class |
| CAngularJointBase | An angular joint is defined by having 2 rotational degrees of freedom |
| CAngularLockJoint | Constraint that removes 3 DOF (rotational degrees of freedom) between two bodies, or one body and the world |
| CArrayParameter | Array parameter |
| CAtomicValueT | AtomicValueT template for integral types, all operations are atomic |
| CAttachment | Constraint attachment base class for any type of frame |
| ►CAttachmentPair | Constraint attachment pair class |
| CCustomData | Custom data for separation pair |
| CInternalState | |
| CAutoInit | Convenience class to automatically call agx::init / agx::shutdown |
| CBallJoint | Constraint that removes the three translation DOF between two bodies (or one and the world) |
| CBallJointFrame | Class for storing the geometric information of a BallJoint |
| CBarrier | Barrier synchronization primitive |
| CBasicControllerConstraint | Base class for constraint angle based elementary constraints (secondary constraints) |
| CBasicThread | Basic wrapper class aroud std::thread |
| ►CBatchAllocator | Batch allocator |
| CChunk | |
| ►CBitArray | Class for stack-storage of a (at compile time) specified number of bits with a minimal size of storage |
| Cconst_reference | Class which is a reference into an existing bitarray |
| Creference | Class which is a reference into an existing bitarray |
| CBitSet_small | Special class for small bitset, because minimum bitset size in clang/gcc is 8 bytes, and we only need 4 |
| CBlock | Block synchronization primitive |
| CBlockStructure | |
| CBodyBodyContactJacobianT | |
| CBodyContactJacobianT | |
| CBoundT | A BoundT represents a range defined by a minimum and a maximum value |
| CBoxedHybridPivotAlgorithm | |
| ►CBoxedKellerAlgorithm | |
| CPivotIndex | Data for pivot index with sign and current range of the most violated index |
| CStepLength | Data for step length with the different thetas and indices (r2 and r3) of other bounded equations that may change state |
| CBoxedMurtyAlgorithm | |
| CBoxFrictionModel | Box friction |
| CBufferPrinter | |
| CBulkMaterial | Physical properties for the bulk of geometries made up by a Material |
| CByteAllocator | Byte allocator |
| CCallback | Generalized callback, using std::function |
| CCallback1 | Templated callback with one argument |
| CCallback2 | Templated callback with two arguments |
| CCallback3 | Templated callback with three arguments |
| CCallback4 | |
| CCallbackComponentVisitor | ComponentVisitor which applies a callback function on each visited node |
| CCellReordering | |
| CCellSortEntry | |
| ►CCellTable | |
| CBucket | |
| Ctemplate_iterator | |
| ►CClock | Clock class keeps representation of virtual/simulated time |
| CFrame | Internal class |
| CFrameWrapper | Internal class |
| CColumnStorage | Class that stores rows and columns of the matrix |
| CComplementaryElementT | |
| CComplementaryElementT< agxSIMD::Jacobian6DOFElement32 > | |
| CComplementaryElementT< agxSIMD::Jacobian6DOFElement64 > | |
| CComplementaryElementT< Jacobian6DOFElement32 > | |
| CComplementaryElementT< Jacobian6DOFElement64 > | |
| CComponent | A component is an object containing other objects, enabling hierarchical structuring |
| CComponentVisitor | Base class for ComponentVisitors |
| CConeLimit | Elementary secondary constraint to set a conic limit to a BallJoint |
| CConeLimitAngle | Implementation of angle for the cone limit |
| CConeLimitData | Basic data holder class for cone limit constraint data |
| CConfigSingleton | Class for holding a reference to the Config db for the core settings defined in the file "settings.cfg" |
| CConstantNormalForceOrientedBoxFrictionModel | Oriented box friction model that uses the same normal force magnitude for all contact points associated to this friction model |
| CConstraint | The base class for a constraint |
| CConstraint1DOF | Specialization for constraints that have only one degree of freedom such as Hinge and Prismatic |
| CConstraint2DOF | Specialization for constraints that have two degree of freedom such as Cylindrical |
| CConstraintAngleBasedData | Basic data holder class for "angle based" (secondary) constraints |
| ►CConstraintImplementation | |
| CBodyView | Interface to the bodies, either user or solver, since these bodies can differ when e.g., a body is merged |
| ►CConstrainedBodiesState | Object that holds the state seen from the user and from the solver |
| CBodiesInfo | Info with number of dynamic and non-static body counters |
| CSolverBodyView | |
| CConstraintNlmcpCallback | Constraint solver callback interface with context and start rows for context |
| CContactForceFilter | A ContactForceFilter provide resting contact forces as seen through either an exponential moving average filter or a median filter |
| CContactForceReader | Class for reading contact forces between rigid bodies and geometries |
| CContactMaterial | This class store the combine material properties between two agx::Material's |
| CContactNormal | |
| CContactTangent | |
| CContainer | The Container is the base class for several of the container classes proided by AGX, such as agx::Vector and agx::HashSet |
| ►CCpuDevice | Representation of the CPU |
| CSyncTag | |
| CCpuKernel | A kernel which executes on the CPU using native C/C++ code |
| CCubicFunction2D | |
| CCubicSplineLookupTable | Base class for spline interpolation between the inserted variable/value pairs |
| CCustomGravityField | The custom gravity field allow a user to derive from this class and implement their own gravity function based on the center of mass of a particle/rigid body |
| CCylindricalJoint | A cylindrical joint is similar to a prismatic joint but with an extra degree of freedom free (rotation around the axis) |
| CCylindricalJointFrame | Helper function to define the reference frame used by the prismatic constraint |
| ►CDate | |
| CTimeVal | A copy of struct 'timeval' from BSD file sys/time.h |
| CDevice | An agx::Device is an abstract representation of a device on which data can be stored and processed |
| CDeviceGroup | A device group contain other devices, enables hierarchical device structuring |
| CDirectMultiTangentsFrictionModel | Friction model with an arbitrary number of tangents in the friction plane |
| ►CDirectSolverData | |
| CContactGroups | Class that handles the grouping |
| CDistanceJoint | This joint will preserve the initial distance between a body and a point in world coordinate or between two bodies |
| CDot1 | Dot1 elementary constraint: Two orthogonal vectors |
| CDot1Data | Data holder class for elementary constraint Dot1 |
| CDot1Joint | Given two vectors or directions, this constraint will keep the two vectors orthogonal |
| CDot1Slack | Dot1Slack is similar to the Dot1 elementary constraint but also supports slack and uses twice as many equations in the solver |
| CDot1SlackData | Extended Dot1Data with additional slack parameter |
| CDot2 | Dot2 elementary constraint: Separation vector orthogonal to direction vector |
| CDot2Data | Data holder class for elementary constraint Dot2 |
| CDot2Slack | Dot2Slack is similar to Dot2 elementary constraint |
| CDot2SlackData | Data holder class for elementary constraint Dot2Slack |
| CDynamicLibrary | |
| CDynamicsSystem | The complete physical system with bodies, interactions, data layout, time stepper, and solver |
| CElectricMotorController | Implementation of a electric motor controller |
| CElementaryConstraint | Elementary constraint base class with interface and global constraint functionality |
| CElementaryConstraintData | Class to hold data for elementary constraints |
| CElementaryConstraintN | Helper class to hold data that is general for elementary constraints |
| CElementaryConstraintNData | |
| ►CElementaryContactPoint | Base class of custom implementations of contact point constraints |
| CInputData | Input data of the geometry contact, which is constant for all contact points |
| CElementaryContactPointFactory | Interface factory for custom contact point constraint implementations |
| CElementaryMultiTangentsContactPoint | Elementary contact point supporting N >= 0 tangents |
| CElementaryMultiTangentsContactPointFactory | Factory for the ElementaryMultiTangentsContactPoint contact model |
| CEmitter | Spawns new bodys inside a given volume |
| CEmptySolver | Algorithm for an island without solve models |
| CEntityDataParameter | Entity parameter |
| CEntityInstanceParameter | EntityInstance parameter |
| CEntityPtrParameter | EntityPtr parameter |
| ►CEulerAngles | This class provides conversion services between Euler angles in any of the 24 conventions and corresponding quaternions and orthogonal 3x3 matrices |
| CEulerOrder | |
| CEulerConvention | |
| CEvent | An event with no arguments |
| CEvent1 | An event with one argument |
| CEvent2 | An event with two arguments |
| CEvent3 | An event with three arguments |
| CEventModel | TODO: Documentation |
| CEventT | An event has a list of listeners (agx::Callback), which are called when the event is triggered |
| CForceField | Fields produce force on physical bodies which have the appropriate charge |
| CFrame | The object defining a frame of reference and providing transformations operations |
| CFrictionController | Translational or rotational friction controller for Hinge, Prismatic and CylindricalJoint |
| ►CFrictionControllerNlCallback | Solver callback class for elementary FrictionController |
| CContextData | |
| CFrictionModel | Base class for all friction models with interface and some utility/necessary methods implemented |
| CGenericConstraint | Generic constraint which by default is empty of elementary constraints |
| CGenericConstraintBodyData | Constraint body data used with GenericElementaryConstraint containing the per body Jacobian data |
| CGenericConstraintComplianceMatrix | Compliance matrix data containing the lower triangle (including the diagonal) of the compliance matrix of the constraint |
| CGenericConstraintData | Constraint data used with GenericElementaryConstraint containing data such as; constraint violation, constraint velocity and bounds |
| CGenericElementaryConstraint | Generic elementary constraint with minimal amount of user callbacks to reduce development/prototype time and trivially exported using SWIG to e.g., Python or C# |
| CGenericJsonParameter | A template class that can be used to read/write a json property and set/get the value in another object |
| CGenericManyBodyConstraint | Generic many-body constraint with callbacks for writing Jacobian and constraint data |
| CGeometryContactConstraint | Class matching geometry contacts given an execute filter and is solving each matching contact point with the given elementary constraint implementation |
| ►CGlobalResult | GlobalResult is used by kernels to generate result data from different threads |
| COverflowBuffer | |
| CTransaction | Transactions are used to reserve exclusive memory areas in which the threads can write their data |
| CGlobalResultBuffer | |
| CGlobalResultStorage | |
| CGranularContactForceReader | Class for reading contact forces between granular bodies and rigid bodies and geometries |
| CGranularDataExporter | Class used to extract data from a granular journal, in the form of writing contact and particle data to file |
| CGranularImpactDataWriter | |
| CGranularReaderWriter | Utility class for reading and writing granular body data to .csv, .agx and .aagx files |
| CGravityField | The class GravityField is responsible for calculating and applying a gravity force on a set of bodies and particles |
| CGridTier | |
| CHashFn | |
| CHashFn< agx::String > | |
| CHashFn< agxSensor::RtEntityId > | |
| CHashFn< const char * > | |
| CHashFn< Int32 > | |
| CHashFn< Int64 > | |
| CHashFn< ref_ptr< T > > | |
| CHashFn< std::pair< T1, T2 > > | |
| CHashFn< std::string > | |
| CHashFn< T * > | |
| CHashFn< UInt32 > | |
| CHashFn< UInt64 > | |
| CHashFn< Vec2T< T > > | |
| CHashFn< Vec3T< T > > | |
| CHashSet | Inheritance with partial specialization due to bug with ref_ptr containers |
| CHashSet< agx::ref_ptr< KeyT >, HashT, AllocatorT > | |
| ►CHashSetImplementation | Same as hash table, but only containing keys, not key-value pairs |
| CBucket | |
| Cinsert_iterator | |
| Ctemplate_iterator | |
| CHashVector | This class is a combined container which has the find complexity of a HashTable, deterministic iteration of a Vector (using begin(), end()) |
| CHighAccuracyTimer | The HighAccurayTimer class can replace the regular Timer class in high level applications where the need for accuracy is greater than performance |
| CHighLevelConstraintImplementation | |
| CHinge | The hinge constraint between two rigid bodies or one rigid body and the world |
| CHingeFrame | Specialization for the constraint frame class that add convenient accessors/mutator methods for manipulation of the geometry of the frame for a Hinge |
| CHybridSolver | Algorithm for hybrid solve |
| CICloneable | Interface class for a cloneable reference counted object |
| CIGenericConstraint | |
| CIndentation | |
| ►CIndexedRangeReal | Data type to bind an index and ranges associated with it |
| CTrace | |
| CIndexLambdaKernel | Utility entrance to the task system, simplifying parallelization of algorithms |
| CIndexListRange | |
| ►CIndexRangeT | A range of indices |
| Citerator | Index range iterator |
| ►CIndexSet | |
| CIpair | |
| CInitCallback | Do not use class directly. Use AGX_INIT_CALLBACK instead |
| ►CINlSolveDataH5 | |
| CData | |
| CInteraction | The base class for interactions |
| CInternalData | Internal data for any object, ObjT, with methods: agx::Referenced* ObjT::getInternalData() const; void ObjT::setInternalData( agx::Referenced* data ); |
| CInterruptException | A specific exception thrown when a signal is caught, as the current simulation step is interrupted |
| CInvalidIndexStruct | Tag for invalid UInt values |
| CIslandEntry | |
| CIterativeProjectedConeFriction | Iterative Projected Cone Friction (IPC friction) model |
| CJacobian6DOFElementT | |
| CJacobianAccessorT | |
| CJacobianMetaT | |
| CJob | An abstract job/workblock representation, which allows work threads to execute arbitrary tasks |
| CJobGenerator | Utility class used to generate jobs for ALL islands |
| CJobGroup | A group of jobs to be executed |
| ►CJournal | |
| CSessionHeader | |
| CJournalCustomDataRecorder | |
| CJsonDataDumpDebug | |
| CKernel | A kernel is an abstract representation of data parallel tasks |
| CLambdaKernel | |
| CLinearLookupTable | Linear interpolation between the inserted variable/value pairs |
| CLinearProbingHashSet | Inheritance with partial specialization due to bug with ref_ptr containers |
| CLinearProbingHashSet< agx::ref_ptr< KeyT >, HashT > | |
| ►CLinearProbingHashSetImplementation | A cache-friendly hash set with open addressing, linear probing and power-of-two capacity |
| Cconst_iterator | |
| Citerator | |
| CLinearProbingHashTable | Inheritance with partial specialization due to bug with ref_ptr containers |
| CLinearProbingHashTable< agx::ref_ptr< KeyT >, DataT, HashT, AllocatorT > | |
| ►CLinearProbingHashTableImplementation | A cache-friendly hash table with open addressing, linear probing and power-of-two capacity |
| Cconst_iterator | |
| Citerator | |
| CLineT | |
| CList | |
| CLocalBodyContactJacobianT | |
| CLocalOverlap | |
| CLocalRollingResistanceJacobianT | |
| CLocalTangentJacobianT | |
| CLockController | Elementary secondary constraint to keep constraint angle at a given target position |
| CLockJoint | Constraint that removes all 6 DOF between two bodies, or one body and the world |
| CLogger | Logger is a class for writing information, debug info, warnings but also throwing exceptions in a stream-alike way |
| ►CLoggerSubscriber | Class for polling messages from the LOGGER system in a Subscriber pattern |
| CLogCallback | |
| CLogicalStructure | |
| CLogStream | Class for printing out messages to console, file, virtual method and or a callback function |
| CLookupTable | Return a value of y given any value of x |
| CLSquareComplianceMatrix | Interface to the lower triangle of the compliance matrix block in the system matrix |
| CLSquareComplianceMatrixRow | Interface to a row in the compliance matrix |
| CMarchingCubes | |
| CMassProperties | Class for rigid body inertia tensor and mass |
| CMaterial | Main material class which acts as a holder of a Surface Material and a Bulk material |
| CMaterialLibrary | Class with functionality to view items in the Material Library and load Materials |
| CMaterialReaderWriter | Utility class for reading and writing Materials |
| CMatrix3x3T | |
| CMatrix4x4T | Matrix class for affine transformations |
| CMatrixType | A class to distinguish between various types of matrices, both in terms of storage properties, i.e., dense or sparse, or lower or upper triangular in the case of symmetric matrices |
| CMcpAlgorithmStats | Storage location for solver statistics |
| CMemoryPool | Memory pool |
| CMemoryPoolOld | |
| ►CMergedBody | Structure holding several "normal" rigid bodies |
| CMergedBodyIndex | Object with index of merged body and the original index of a merged object |
| CPoint | Contact point data store in first rigid body local frame |
| CMixedLCPOld | Definition of a mixed LCP problem |
| CMLCP | |
| ►CModel | A model is an abstract representation of the class of an agx::Object |
| CLoader | |
| CName | Representation of a name string |
| CNamespace | A namespace is used as a group node in the agx::Model hierarchy |
| ►CNlmcpCallback | Interface class for solver callbacks |
| CArgs | |
| CNlmcpCallbackSolverData | Data from the solver the ConstraintNlmcpCallback is part of |
| ►CNlMixedCp | Class that implements a method to solve linear- or nonlinear complementary problems |
| ►CMcpAlgorithm | Interface class for algorithm to solve general mixed complementarity problem |
| CArgs | Structure for all the arguments passed around |
| CException | |
| CSolveReport | |
| CNotify | Class for handling logging of messages |
| CNotifyCallback | Callback class, derive from this and Register to the notify singleton to get callbacks |
| ►CObject | Agx::Object is a refcounted object with a name |
| CEvent | |
| CObjectWrapper | |
| Cobserver_ptr | Smart pointer for observed objects, that automatically set pointers to them to null when they deleted |
| CObserverFrame | With this class you can attach an ObserverFrame object relative to a RigidBody |
| COctaveDumper | |
| COrientedBoxFrictionModel | Box friction model with oriented friction box |
| COrientedFrictionModelImpl | Oriented friction box base implementation containing a frame of reference and the primary direction given in that frame |
| COrientedIterativeProjectedConeFrictionModel | Iterative projected cone friction model with oriented friction box |
| COrientedScaleBoxFrictionModel | Scale box friction model with oriented friction box |
| COrthoMatrix3x3 | Specialized types of matrices for holding orthogonal transformation matrices |
| CParallelRaContainerKernel | |
| CParallelTask | ParallelTask |
| CParameter | A representation of a task/kernel parameter, which can be bound using a string path or explicitly to a data node |
| CParameterBinding | A binding between a formal function parameter and an actual value |
| CParticleBodyContactJacobianT | |
| CParticleContactSensor | This class is for detecting and handling particle collisions with geometries in the simulation |
| CParticleContactWire | |
| CParticleEmitter | Spawns new particles inside a given volume given to the Emitter |
| CParticleParticleContactJacobianT | |
| CParticleSink | A sink which destroys particles |
| ►CParticleSystem | A basic particle system that contains all the storages and buffers required for basic operation and also a rendering task |
| CMaterialUuidBufferListener | |
| CUpdateRenderingListener | |
| ►CPath | Representation of a path, a list of name components |
| Citerator | |
| CPlaneJoint | |
| CPlaneT | Class representing the mathematical concept of a plane, also called a half- space |
| CPoint2D | |
| CPointer | A pointer to an agx::Object |
| CPointerParameter | Pointer parameter |
| CPointerT | |
| CPointGravityField | The class PointGravityField calculates a gravity which is uniform in magnitude over the entire space and directed from the given position outwards from origin |
| CPrismatic | A prismatic joint keeps a fixed relative orientation between the attached bodies but allows them to slide along a given axis |
| CPrismaticFrame | Helper function to define the reference frame used by the prismatic constraint |
| CPrismaticUniversalJoint | A Prismatic Universal Joint has two translational dof's constrained |
| CPropertyContainer | Class that is a container of named properties |
| CPureDirectSolver | Algorithm for pure direct solve |
| CPureIterativeSolver | Algorithm for pure iterative solve |
| CQuadraticProbingHashTable | Inheritance with partial specialization due to bug with ref_ptr containers |
| CQuadraticProbingHashTable< agx::ref_ptr< KeyT >, DataT, HashT, AllocatorT > | |
| ►CQuadraticProbingHashTableImplementation | A simple hash table using quadratic probing |
| CBucket | |
| Cinsert_iterator | |
| Ctemplate_iterator | |
| CQuatLock | Locks the three rotational degrees of freedom (relative coordinates) |
| ►CQuatLockData | Data holder class for elementary constraint QuatLock |
| CQuatTransformer | The class holding the actual data and that transforms the data |
| CQuatT | The object holding quaternions and providing operations on these |
| ►CRandomGenerator | |
| Cvariate_generator | |
| CRange | A range object has a min and max value of a given type and provides services to tell whether a value is in that range or not |
| CRange6T | |
| CRangeController | Elementary secondary constraint to keep constraint angle within two given values |
| CRangeJob | A range job executes a kernel implementation on a subset of the data |
| CRangeJobT | |
| CRangeViolation | This class will store a computed violation of a range |
| CReaderWriterLock | ReaderWriterLock provides shared access for readers and exclusive access for writers |
| CRealEntry | SparseInverse holds a subset of the columns of the inverse of a given sparse matrix |
| CRealTimeClock | |
| CRealTimeTrigger | |
| Cref_ptr | Smart pointer for handling referenced counted objects |
| CReferenced | Base class providing referencing counted objects |
| CReferencedHandler | Holds references to instances given common or unique type |
| CReferencedModel | Abstract description of the data attributes for the Referenced entity |
| CReferencedPtr | Pointer to a entity instance of type Referenced |
| CRefPtrAccessor | |
| CRefWrapper | Utility class to be able to use reference counting on objects which does not support it natively |
| CRegularizationParameters | All ghost variables have compliance and damping attributes |
| CRigidBody | The rigid body class, combining a geometric model and a frame of reference |
| CRigidBodyAttachment | Constraint attachment class for agx::RigidBody |
| CRigidBodyEmitter | Spawns new Rigid Bodies inside a volume given to the Emitter |
| CRigidParticleSystem | A specialization of the particle system that simulates the particles as a set of hard core spheres |
| CRollingResistanceJacobianT | |
| CRotationalAngle | Implementation of constraint angle ABOUT an axis |
| CRowAllocator | Class to allocate an array of elements where some other structure works on pointer |
| CRuntime | Will read a license file upon creation and check what configuration is allowed to run |
| CScalarParameter | Scalar parameter |
| CScaleBoxFrictionModel | Scale box friction |
| CScrewController | |
| CSeparationAngle | Implementation of constraint angle ALONG an axis |
| CSerialTask | SerialTask |
| CSetVector | This class is a combined container which has the find complexity of a HashTable, deterministic iteration of a Vector (using begin(), end()) |
| CShutdownCallback | |
| CSimpleContactMaterial | |
| CSingleton | Base class for Singletons that should have its shutdown called explicitly before exit of the application |
| CSlack3ConstraintData | Generic class for holding constraint data including 3 slack parameters |
| CSlackCylindricalJoint | A constraint that is equal to the |
| CSlackHingeJoint | A constraint that is equal to the |
| CSlackLockJoint | A constraint that is equal to the |
| CSlackPrismaticJoint | A constraint that is equal to the |
| ►CSolveAlgorithm | Parent class for solve algorithms compatible with the constraint framework |
| ►CTask | Algorithm task either empty, single or group type |
| CConditionData | The type of tasks may depend on the data in this structure |
| CSolveIslandSplitAlgorithm | The rigid body class, combining a geometric model and a frame of reference |
| CSparseInverse | |
| CSparseMatrix | Agx::SparseMatrix holds a matrix representation which contains the data |
| CSparseMatrixRep | SparseMatrixRep |
| CSparseMatrixRepSabre | |
| CSparseRangeReal | Essentially a sparse array of bounds |
| CSparseVector | A sparse vector here is an Vector of entries with a few additional operations for creation and sorting |
| CSPDMatrix3x3 | Specialized type of matrices for holding symmetric positive definite matrices |
| CSpherical | Spherical elementary constraint: Two points in world coincide |
| CSphericalRel | Spherical elementary constraint: Two points in world coincide |
| CSphericalRelSlack | SphericalRelSalck is similar to the SphericalRel elementary constraint, but also supports slack and uses twice as many equations in the solver |
| CSpinMutex | Spin-lock mutex |
| CSplineJoint | A SplineJoint is a constraint with a motor/range/lock for translation/rotation that will restrict a body to move along a spline path |
| CSplitNode | |
| CSplitNodeSeparator | |
| ►CStabilityReport | |
| CDiff | |
| CFrame | |
| CPotentialConstraintIssue | |
| CPotentialContactIssue | |
| CStackAllocator | The StackAllocator class is designed to be used with the STL vector class |
| CStackArray | Templated stack array class |
| CStaticDataInitializer | |
| CStaticInitializer | |
| CStaticShutdown | |
| ►CStatistics | Base statistics gathering class |
| CData | Statistics data storage class |
| CStatisticsFrameReader | |
| CStream | TODO: Documentation |
| ►CStrongInteraction | Base class for a strong interaction concept where there interaction is defined in the mass matrix part of the system matrix |
| CMatrixData | |
| CStrongInteractionConstraint | EXPERIMENTAL |
| CSurfaceMaterial | Physical properties for the surface of a Material |
| CSwing | Swing elementary constraint: Two orthogonal vectors with hookean behaviour |
| CSwingData | Data holder class for elementary swing constraint |
| CSwingTwistLock | Constraint that removes all 6 DOF between two bodies, or one body and the world |
| CSymmetricPair | A std::pair, with both elements of the same type, and symmetric so (a, b) == (b, a) |
| CSystemInformation | |
| CTangentJacobianT | |
| CTargetSpeedController | Elementary secondary constraint to drive something given target speed (translational or rotational) |
| CTask | A representation of a generic task |
| CTaskGroup | TaskGroup |
| CTaskJob | A task job is a job which executes an agx::Task |
| CTaskLoadError | |
| CTaskManager | |
| CTaskPlugin | |
| CTaskPluginImplementation | |
| CTaskPluginImplementationT | |
| CTaskTimingModel | Abstract description of the data attributes for the TaskTiming entity |
| CTaskTimingPtr | Pointer to a entity instance of type TaskTiming |
| CThread | Agx::Thread is a representation of an OS specific implementation of a computational thread |
| CThreadLocalAllocator | |
| CThreadTask | |
| CThreadTimelineEntryModel | Abstract description of the data attributes for the ThreadTimelineEntry entity |
| CThreadTimelineEntryPtr | Pointer to a entity instance of type ThreadTimelineEntry |
| CTimeGovernor | |
| CTimer | Permits timing execution speed with the same refinement as the built in hardware clock of the CPU |
| CTimingInfo | |
| CTwist | Twist elementary constraint |
| CTwistData | Data holder class for elementary constraint Twist |
| CTwistRangeController | Twist range elementary constraint |
| ►Cuint32_t_union | |
| Cuint32_t_struct | |
| CUniformGravityField | The class UniformGravityField calculates a gravity which is uniform in magnitude over the entire space and directed along a specified vector |
| CUniqueIdStruct_ | Struct holding information about a Unique Id |
| CUniversalJoint | A Universal Joint has one fixed relative point, the 3 translational dof's, and one constrained axis (the rotation around the N axis of each frame the bodies) |
| CUnresolvedParameter | Unresolved parameter |
| CUnresolvedTask | |
| ►CUuid | A UUID, or Universally unique identifier, is intended to uniquely identify information in a distributed environment without significant central coordination |
| CData | |
| CLess | Sorting functor of an uuid |
| CUuidGenerator | Generator of UUID values based on V4 http://en.wikipedia.org/wiki/Universally_unique_identifier |
| CVec2T | |
| CVec3T | A class holding 3 dimensional vectors and providing basic arithmetic |
| CVec4T | A class holding 4 dimensional vectors and providing basic arithmetic |
| CVec6 | |
| CVector | Templated vector class |
| CVectorPOD | Vector containing 'raw' data |
| ►CVirtualConstraintInertia | This class will add a virtual inertia along or around the constraint axis (N-axis), which will affect the resulting rotational or translational acceleration on the affected rigid bodies |
| CTransformed | |
| CWaitJob | A job used as a synchronization utility when waiting for another job to complete |
| CWireContactBendConstraint | |
| CWireContactConstraint | A one row constraint |
| CWireContactDistanceConstraint | |
| CWireContactFrictionConstraint | |
| CWireContactSolver | Given a wire, and positions along the wire, we solve for new contact positions |
| CWireContactSpringConstraint | Ad-hoc constraint to find normalforces (it is a distanceconstraint in normaldirection of the contact nodes) |
| CWireMaterial | Physical properties for the contact between a Geometry and an agx::Wire |
| CWireParticle | |
| CWorldFrameBallJoint | Special version of a ball joint where the spatial reference frame is world for the body/bodies |
| CXmlLoaderRegistrator | |
| ►NagxCable | Contain classes for 6 DOF lumped element cables/wires/ropes |
| CBodyFixedNode | A cable node that is attached to a RigidBody |
| CCable | A model of a cable using a lumped elements model |
| CCableDamage | Used to estimate damage caused to a cable during a simulation |
| CCableDamageState | Inspect a cable's current state and compute a SegmentDamageState for each segment |
| CCableDamageStateFilter | A bit set used by the cable damage framework to control which parts of the cable damage input that a CableDamageState instance should calculate |
| CCablePlasticity | |
| CCableProperties | Class controlling material properties of one or more cables |
| CCablePropertiesReaderWriter | Class with methods to read and write CableProperties from and to json files or strings |
| CCableSegment | A CableSegment represents a single link of a cable |
| CCableTunnelingGuard | A linked structure componenent which uses additional sensor geometries placed around each segment to register addtiional context to the solver as to reduce the preseence of tunneling between cables |
| CDeformationData | |
| CFreeNode | A cable not that is simply a point in space |
| CGeometryFactory | |
| CHomogeneousSegmentsRoute | An ordered collection of agxCable::Node objects that has been added to a particular cable |
| CIdentityRoute | A route that creates segments directly from the routing nodes |
| CPathRoute | A route that creates a path roughly following the routing nodes |
| CPointSegmentAttachment | |
| CRigidSegmentAttachment | |
| CRoute | Legacy route type that exist solely for the purpose of restoring old serializations |
| CRouteInitializationReport | |
| CRoutingNode | Base class for route nodes that defines the path and some behavior of a cable |
| CSegmentAttachment | |
| CSegmentAttachmentT | Helper class to create give type of constraint for the different SegmentAttachments |
| CSegmentDamage | A SegmentDamage instance records damages estimates computed for a single cable segment |
| CSegmentDamageState | A SegmenDamageState instance records a collection of states computed from a cable for later use by a cable damage estimation model |
| CSegmentingRoute | A route that finds a segment length that divides the route legs as evenly as possible |
| ►NagxCollide | This namespace consists of a set of classes for handling geometric intersection tests including boolean tests, penetration and contact sets |
| ►NagxGeometryQueries | Implementations |
| CLine | An infinite line, defined by a starting point and a (not necessarily normalized) direction |
| CLineSegment | A line segment. Note that the direction does not have to be normalized |
| CSweptLineSegment | A line segment that is swept in time from t=0 to t=1 |
| ►Ndeprecated | |
| CConvexBuilder | Class for creating convex meshes from a set of vertices and indices |
| CBoundingAABB | Axis aligned bounding box implementation |
| CBox | A box shape for geometric intersection tests |
| CCapsule | Implements a Capsule shape for geometric intersection tests |
| CColliderTable | |
| CColliderTableCleanup | |
| CCollisionGroupManager | |
| CCollisionMeshData | Class for data sharing only to be used by Mesh, its internal classes and children |
| CCone | A right circular cone shape for geometric intersection tests |
| CContactPoint | A contact point in a contact data |
| CContactReducer | Class for contact reduction |
| CContactRegionManager | Class for merging contact regions and computing their normals |
| CConvex | A convex class for geometric intersection tests |
| ►CConvexFactory | Class for creating convex meshes from a set of vertices and indices |
| CParameters | |
| CVHACDParameters | |
| CCylinder | A cylinder shape for geometric intersection tests |
| CDisabledCollisionsState | Complete disabled collisions state in a simulation including disabled given name, group id (integer) and geometry pair |
| CFallbackConvexCollider | This template class can be instantiated to use Convex-Convex for shape pairs where no explicit collider exists |
| CGeometry | The geometry representation used by the collision detection engine |
| CGeometryCollider | The geometry collider is responsible for finding contacts between two geometries |
| CGeometryContact | A contact between two geometries |
| CGeometryPtrPair | |
| CGroupIdCollection | Collection of geometry group names and id's |
| CGroupIdPair | |
| CHeightField | A HeightField is a collision shape that can be created from a grid structure, like an image |
| CHeightFieldMeshData | Class for data sharing only to be used by HeightField |
| CHierarchicalGrid | |
| CHollowCone | A right circular hollow cone shape for geometric intersection tests |
| CHollowCylinder | A hollow cylinder shape for geometric intersection tests |
| CLine | A line shape for intersection tests, mostly for depth sensing and picking |
| CLineSegmentIntersectionFinder | |
| CLocalContactPoint | |
| CLocalGeometryContact | |
| CLocalParticleGeometryContact | |
| CLocalParticlePairContact | |
| ►CMesh | Mesh is a common base class for triangle meshes, such as Mesh or HeightField |
| CFaceEdgeCirculator | Class in order to circulate over the edges connected to a Triangle's face |
| CTriangle | Class for more intuitive access to the Mesh's mesh data |
| CTriangleLineSegmentResult | Struct used in calculateTriangleOverlapsAlongLineSegment |
| CVertexEdgeCirculator | Class in order to circulate over the edges connected to a Triangle's vertex |
| CMeshData | Stores triangle mesh data as triangle lists, i.e |
| CNamePair | |
| CPlane | |
| CPolynomial | |
| CRegressionPlane | A plane created from points using least squares minimization |
| CRenderData | Class for storing rendering information for a Shape |
| CRenderMaterial | Class for storing rendering material |
| CShape | Base class for a shape |
| CSpace | This class contains all Geometries and performs Broad Phase and Narrow Phase collision detection to calculate overlapping Geometry pairs |
| CSpaceListener | Class for listening for add/remove geometry events for an associated Space |
| CSphere | A sphere class for geometric intersection tests |
| ►CSweepAndPrune | |
| Cendpoint | |
| CUpdateTask | |
| CTriangleVoronoiRegion | Class containing the Voronoi region of a triangle as an uint8_t |
| CTrimesh | Triangle mesh for geometric intersection tests |
| ►CVoronoiGenerator | |
| CVoronoiCell | |
| CWireShape | Internal class used by agxWire::Wire |
| ►NagxControl | This namespace contains general operation and action classes which can be used to control a agxSDK::Simulation |
| CBaseRecordParticleJournalOperation | Base virtual class for storing particle states to an external journal file |
| CCalculateTotalMass | |
| CCalculateTotalMassFlow | |
| CCalculateTotalRigidBodyDEMMass | |
| CCalculateTotalRigidBodyDEMMassFlow | |
| CColorParticles | This operation changes the color of the particles given in the contact |
| CDataFilter | Virtual base class of a data filter for data smoothing |
| ►CEventSensor | This is a sensor class that can be attached to an geometry in the simulation |
| CContactInformation | |
| CEventPrioHolder | |
| CGeometryContactEventListener | |
| CParticleContactInformation | Placeholder for information regarding the particle contacts |
| CParticleContactListener | |
| CExponentialFilter | Exponential filter that smoothes values in the form: x_filter(t) = a * x_filter(t-1) + ( 1 - a ) * x_raw(t) where a = exp( - dt / T ) |
| CLoadParticleAGXFileOperation | Loads particle data from an external agx file into a simulation relative to the coupled sensor object |
| CLoadParticleJournalOperation | Loads particle data from an external journal file into a simulation relative to the coupled sensor object |
| CMakeParticleKinematicOperation | This operation applies a "kinematic state" to particles that collide with the sensor |
| CMeasurementSensor | |
| CMeasurementSensorOperation | |
| CParticleContactDumper | This operation dumps particle contact information to a file |
| CParticleKinematicSleepOperation | This operation applies a kinematic "sleep state" to particles inside the sensor that are under a specified velocity threshold |
| CRecordParticleJournalOperation | Class that stores particle data from a continuous flow in the coupled sensor to a separate specified journal file |
| CRecordParticleShapshotJournalOperation | Class that stores a single frame of the current particle configuration in the coupled sensor |
| CRemoveParticles | This operations removes all the particles in the contact supplied by the sensor |
| CRemoveRigidBody | This operation removes the rigid body given by the geometry in the contact supplied by the sensor |
| CReplaceParticleMaterialOperation | |
| CResetParticleContactEnergyOperation | This operation resets accumulated impact energy to a set value for particles inside the sensor if the buffer exists in the granular system |
| CRigidBodyDEMVolumeCalculator | |
| CSensorEvent | A sensor event is an event triggered when the sensor is activated by a contact |
| CSensorOperation | A specific type of sensor event that triggers a change in the simulation when activated by a contact |
| CSetVelocityOperation | This sensor operation class sets a speed to the object that collides with the sensor, in both linear and angular direction |
| ►CSplitSensorOperation | |
| CParticleStorageListener | |
| CStoreParticlesOperation | This sensor operation class store particle id's of particles that are in contact with the sensor |
| CTagOperation | This operation can be used to know when a sensor has been activated by a contact |
| CTeleportToSensorOperation | This sensor operation can teleport contacting particles to a target sensor geometry with arbitrary time dilation |
| CVolumeCalculator | |
| CWriteParticleDataToAGXOperation | Class that stores particles in contact with the sensor to an binary .agx file |
| ►NagxData | Contains classes for low level data storage for AGX |
| CAbstractArray | Arrays are fast accessors into the data, or a portion of it, held by a Buffer |
| CAbstractScalar | Abstract representation of a scalar variable |
| ►CagxData | Representation of a session on disk created by the FileFrameWriter |
| CFrameInfo | |
| CArray | Type-specific Array used for fast access into the data held by a Buffer |
| CArrayAttribute | An array attribute |
| CArrayAttributeT | |
| CArrayFormat | |
| CAttribute | An abstract attribute description, part of an Entity |
| CAttributeContainer | An attribute container |
| CAttributePtr | |
| CBinaryData | |
| CBuffer | Abstract representation of a data buffer |
| CBufferProxyAllocator | |
| CBufferT | |
| CByteStream | Utility class for parsing/writing a byte stream |
| CCallbackList | List of callbacks used by the primitive type handling by user code |
| CChannel | A channel is a directional data transfer connection between two buffers |
| CCondition | |
| CContainerAttribute | A container attribute (Array/Vector/HashSet) |
| CContainerFormat | Container format, eg |
| CData | Generic data |
| CDebugFrameWriter | The DebugFrameWriter prints the contents processed frames |
| CDiskFrameReader | Helper class for the FrameReaders that are backed by a file on disk |
| CDiskFrameWriter | Base class for the FrameReaders that are backed by a file on disk |
| CEntityInstance | Entity instance provides access to a single instance in an EntityStorage |
| ►CEntityModel | An abstract description of a data entity stored using SOA (structure of arrays) pattern in a EntityStorage |
| CLoaderT | |
| CEntityPtr | Accessor to a entity instance stored in a EntityStorage, to allow SOA (structure of arrays) data to be accessed using a AOS (array of structures) pattern |
| CEntityRange | |
| CEntityRef | An entity reference is a safe/referencing handle to an entity instance whose model is descendant from Referenced.agxEntity |
| CEntityStorage | Data storage for a collection of entity instances of a specified EntityModel |
| CFileFrameReader | Frame reader that supports the files-and-foldes prototype format |
| CFileFrameWriter | |
| CFileJournal | The FileJournal provides a way to inspect and manipulate a journal created by the FileFrameWriter and stored on disk |
| CFormat | A format is an implementation of a agxData::Type |
| CFormatBinding | |
| CFormatBinding< T * > | |
| CFormatCaller | |
| CFormatCallerT | |
| CFormatInitializer | |
| CFormatMoveSwap | |
| CFormatMoveSwap< agx::HashSet< T > > | |
| CFormatMoveSwap< agx::HashTable< KeyT, DataT > > | |
| CFormatMoveSwap< agx::Vector< T > > | |
| CFormatMoveSwapContainer | |
| CFormatT | Templated format, connects the type abstractions to the programming language |
| CFrameChannel | Convenience class that store a FrameReader and a FrameWriter |
| CFrameIO | |
| CFrameReader | The FrameReader reads frames from an external source |
| CFrameTranspose | |
| CFrameWriter | The FrameWriter writes frames to an external target |
| CFunctionValue | |
| CGenericFormat | |
| CGenericStruct | |
| CHashSetAttribute | A hash set attribute |
| CHashSetAttributeT | |
| CJournalArchive | The JournalArchive provides an abstract class for inspecting and manipulating the contents of a created journal |
| CLocalVector | Local scope vector |
| CPointerAttribute | A pointer attribute |
| CPointerAttributeT | |
| CScalar | Templated scalar |
| CScalarAttribute | A scalar attribute |
| CScalarAttributeT | |
| ►CSerializedFrame | |
| ►CBinaryHeader | |
| CBuffer | |
| CComponent | |
| CCreateInstanceEvent | |
| CCreateInstancesEvent | |
| CCustomBuffer | |
| CDataNode | |
| CDestroyInstanceEvent | |
| CDestroyInstancesEvent | |
| CEntityStorage | |
| CEvent | |
| CFrameExtractor | |
| CFrameMeta | |
| CNode | |
| CPartialBuffer | |
| CPermuteEvent | |
| CStorageBatchEvent | |
| CStorageEvent | |
| CValue | |
| CBinarySegment | |
| CJsonHeader | |
| CXmlHeader | |
| CSharedAttribute | A shared attribute |
| CSharedAttributeT | |
| ►CShareHandle | |
| CPlatformBridge | |
| CStackArray | |
| ►CTrack | |
| CInputThread | |
| COutputThread | |
| CThread | |
| CType | Abstracted type |
| CTypeBinding | Type binding, templated type -> abstract type |
| CTypeBinding< T * > | |
| CTypeImplementation | |
| CVal | Only use as member allocated variable |
| CValue | Abstract representation of a value |
| CValueRefT | Templated value-reference |
| CValueT | Templated value |
| CVector | |
| CVectorAttribute | A vector attribute |
| CVectorAttributeT | |
| ►NagxDriveTrain | A library of agxPowerLine components designed to model the various parts of a vehicle drive train |
| ►Ndeprecated | |
| CClutch | |
| CCombustionEngine | |
| CDriveTrainComponent | A DriveTrainComponent is a Shaft that comes with a Connector and an input shaft |
| CFixedGear | The gear box can have an arbitrary number of gears |
| CGearBox | The gear box can have an arbitrary number of gears |
| CHighLevelDifferential | Implementation of a differential |
| CHighLevelGearBox | The gear box can have an arbitrary number of gears |
| CHighLevelTorqueConverter | Implementation of a torque converter (TQ) The characteristics of a real TQ is captured in two look up tables |
| CTorqueConverter | Base Torque converter for an automatic transmission |
| CTorqueConverterSpeedRatioLookup | Lookup table where the lookup variable depend on the velocity ratio between in and output |
| CTorqueConverterTable | Base Torque converter for an automatic transmission |
| CBrake | |
| CClutch | Defines a viscous coupling between two rotational dimensions |
| CCombustionEngine | The model of the combustion engine consists of two subsystems: namely, the intake manifold dynamics and the rotational dynamics |
| CCombustionEngineParameters | Parameters that specifies the performance of a combustion engine |
| CCombustionEngineParametersReaderWriter | Class with methods to read and write CombustionEngineParameters to and from JSON files or JSON formatted strings |
| CDifferential | A differential for distributing the torque evenly between an arbitrary number of output shafts |
| CDifferentialLockConnector | Connector for locking of the differential |
| CDryClutch | Single disk plate clutch with dry friction |
| CElectricMotor | An electric motor is a roational unit that is a source of power in a drive train |
| CElectricMotorConstraint | |
| CElectricMotorConstraintImplementation | |
| CEnergyManager | |
| CEngine | An engine that is driven by an EnginePowerGenerator |
| CEngineDampingUpdater | The engine provided by the power line implementation is based on Euler integration and is unstable in the presence of large derivatives in the power curve |
| CEnginePowerGenerator | Power generator that adds torque to the engine according to a lookup table |
| CFixedVelocityEngine | An engine that tries to hold a fixed velocity |
| CFrictionTorqueParameters | Parameters controlling the mean effective friction torque |
| CGear | A gear is a connector between two rotational units |
| CGearBox | The gear box can have an arbitrary number of gears |
| CHolonomicGear | A Gear that uses a holonomic constraint instead of the default nonholonomic contstraint |
| CMultiGear | A MultiGear is a type of gear connector that can have multiple connected shafts, each with its own gear ratio |
| CPidControlledEngine | Implementation of a combustion engine |
| CRpmController | ThrottleCalculator that strives to keep the engine at some given RPM |
| CShaft | A Shaft is the most basic PowerLine Unit |
| CSlipGear | Defines a viscous coupling between two rotational dimensions |
| CThrottleCalculator | Inherit from the ThrottleCalculator and implement the calculateThrottle() function to control the torque of a PidControlledEngine |
| CTorqueConverter | A torque converter is a connector, which transfers rotating power with the help of a fluid coupling |
| CVelocityConstraint | A constraint holding a single VelocityConstraintImplementation |
| ►NagxFMI2 | This namespace contains functionality for using AGX together with version 2 of the Functional Mockup Interface (FMI) standard |
| ►NExport | |
| CGeometrySurfaceVelocityInputVariable | |
| CGeometrySurfaceVelocityOutputVariable | |
| CGeometryVec3AttributeInputVariable | |
| CGeometryVec3AttributeOutputVariable | |
| CRigidBodyAttributeInputVariableReal | |
| CRigidBodyForceAccumulatorInputVariable | |
| CRigidBodyPositionInputVariable | |
| CRigidBodyPositionOutputVariable | |
| CRigidBodyRotationEulerInputVariable | |
| CRigidBodyRotationEulerOutputVariable | |
| CRigidBodyRotationQuatInputVariable | |
| CRigidBodyRotationQuatOutputVariable | |
| CRigidBodyTorqueAccumulatorInputVariable | |
| CRigidBodyVec3AttributeInputVariable | |
| CRigidBodyVec3AttributeOutputVariable | |
| ►NagxGL | This namespace contains OpenGL specific details for connecting OpenCL/OpenGL |
| CBuffer | |
| CCamera | |
| CCapabilityState | |
| CDepthMaskState | |
| CDevice | |
| CFragmentShader | |
| CGeometryShader | |
| ►CKernel | |
| CShaderVariable | |
| CLights | Container class for lights that is used for synchronizing light data with shaders, such as particle sprite shaders |
| CLineWidthState | |
| CPointSizeState | |
| CPolygonModeState | |
| CRenderBoxIndices | |
| CRenderBoxNormals | |
| CRenderBoxOutlines | |
| CRenderBoxVertices | |
| CShader | |
| CState | |
| CSyncTag | |
| CTask | |
| CTexEnvState | |
| CVertexShader | |
| ►NagxHydraulics | The agxHydraulics namespace contains classes for modeling hydraulic circuits within the power line framework |
| ►Ndeprecated | |
| CMotorUnit | |
| CPumpUnit | |
| ►Ndetail | The detail namespace contains helper classes that user code should not create directly but may receive as return values from accessor methods or factory functions |
| CElementaryGraphJoiningConstraint | |
| CGraphJoiningConnector | |
| CGraphJoiningConstraintImplementation | |
| CSpoolValveConnector | |
| CSpoolValveStaticFlowUnit | |
| CVariableDisplacementPumpParameters | |
| CAccumulator | An accumulator is a component that stores fluid and pressure |
| CCheckValve | A check valve is a FlowUnit that only allows flow in one direction |
| CConstantFlowValve | A constant flow valve is a valve that acts to limit the flow rate through a pipe to some maximum value |
| CFlowConnector | A FlowConnector is a junction of a set of FlowUnits |
| CFlowDimension | A FlowDimension represents the flow of fluid through a FlowUnit |
| CFlowDirection | Enum describing the possible flow directions |
| CFlowUnit | FlowUnit is the base class for Units that contains a FlowDimension |
| CHydraulicMotorActuator | An Actuator that converts hydraulic flow into rotation of a hinge |
| CHydraulicPumpActuator | An Actuator that converts rotation of a hinge into hydraulic flow |
| CImpellerActuator | Base class for Actuators that convert between hydraulic flow and mechanical 6-DOF rotation, e.g., the HydraulicPumpActuator and the HydraulicMotorActuator |
| CMotor | A PowerLine Connector that connects a flow input to a rotational output |
| CNeedleValve | A needle valve represents a controllable orifice opening |
| CPipe | A pipe carries fluid flow through the hydraulics system |
| CPistonActuator | A PistonActuator is a model of a hydraulic cylinder |
| CPistonActuatorConnector | The PistonChamberConnector is an internal Connector to the PistonActuator |
| CPressureConnector | The PressureConnector is an abstract base class for all Connectors that has a pressure |
| CPump | A PowerLine Connector that connects to a rotational input and a flow output |
| CReliefValve | The relief valve is a hydraulic component that limits the pressure at some point in the system |
| CRotationalFlowConnector | Abstract base class containing overlapping functionality for pump and motor |
| CSpoolValve | Spool valves are used to dynamically redirect flow during a simulation |
| CStopValve | A stop valve is either completely open or completely closed |
| CVariableDisplacementPump | The VariableDisplacementPump is a pressure regulated pump that automatically alters its own displacement in order to maintain a target pressure |
| ►NagxIO | The agxIO namespace contains classes for reading, writing and finding files |
| ►CArgumentParser | A small argument parser class |
| CArgument | Help class for handling arguments |
| CDeviceManager | Class which controls all input devices, initialization, destruction etc |
| CEnvironment | Class for setting search path for locating dynamic libraries, scripts etc |
| CFileExtension | Support mesh file formats |
| CFilePathContainer | Class for locating files |
| CFileState | Class for storing and comparing a change date for a file on disk |
| CFileStateVector | Vector for holding a set of file states, where the vector can be asked if any of the files has been changed |
| CFileSystem | |
| CImage | Class to represent Images |
| CImageReader | Base class for ImageReaders |
| CImageReaderPNG | ImageReader for png-files |
| ►CJoystick | Alternative Joystick interface for gamepads etc |
| CState | Class for storing a Joystick state |
| CJoystickListener | Class that can be used to listen to events generated by a GamePad or Joystick |
| CJoystickManager | A Joystick/GamePad manager that initializes the connected devices and allows for adding listeners |
| CJoystickState | Store the current state of a Joystick/GamePad |
| CKeyEvent | |
| CMeshReader | Class for reading a mesh object from file and extracting vertices, normals and indices for collision detection Notice that this class will read the mesh vertices/indices as is |
| CMeshReaderOBJ | Class for reading a Wavefront OBJ file |
| CPNGImageValueInterpreter | |
| CPovExporter | Class for exporting a simulation into AGX .pov format |
| CResourceManager | |
| ►NagxModel | Contain classes for higher level modeling primitives, such as Tree, Terrain etc |
| ►Ndense | |
| CSquareMatrix | |
| CVector | |
| CAddedMassAlgorithm | |
| CAddedMassDb | Holder/manager of added mass storages |
| ►CAddedMassStorage | Storage that holds data needed for added mass calculations |
| CReport | Report from creation, store and restore |
| CAerodynamicsParameters | |
| CBeam | Beam is a segmented, lumped element structure of a given length and resolution |
| CBeamContactHandler | Beam component manipulating contacts with the beam, preventing contact normals from being along the beam, e.g., contact points generated between two beam segments |
| CBeamModel | Beam model interface requiring moment of inertia (area moment in x, y and polar moment in z), the cross section area, 2D (x and y) extents and geometry for the segments |
| CBeamModelProperties | Bulk beam model properties present in all agxModel::BeamModel instances, which in turn propagates the bulk material properties to the constraints in an agxModel::Beam |
| CBeamModelPropertiesReaderWriter | Class with methods to read and write BeamModelProperties from and to json files or strings |
| CBeamSegment | Beam segment in an agxModel::Beam containing a rigid body, a constraint and is of fixed length |
| CBeamStiffnessDamping | Stiffness and damping data for constraints related to beam models |
| CBuoyancyAlgorithm | |
| CCenterOfBuoyancyAlgorithm | |
| CCircularBeam | Circular cross section beam model with a given radius |
| CConstantWaterFlowGenerator | Class to generate constant water flow in a scene |
| CConstantWindGenerator | Class to generate constant wind in a scene |
| CContactMeasurement | |
| CController1D | A simple base class for a controller with a set point and an out signal |
| ►CControllerHandler | This is a PID handler that collects the Plant measured Process Variable (PV) and execute PID update() to set a new Manipulated Variable (MV) for the Plant |
| CPlant | The Plant (aka the Physical System) is added to the ControllHandler in the Control System |
| CDeformable1D | One dimensional deformable construction, i.e., objects attached successively |
| CDeformable1DBoxGeometryFactory | Geometry factor for boxes of given width and height |
| CDeformable1DBulkProperties | Class containing and updating material properties of a Deformable1D object |
| CDeformable1DCapsuleGeometryFactory | Geometry factory that creates Capsules with given radius |
| CDeformable1DComponent | Base class for all classes that add behavior to or inspect a Deformable1D |
| CDeformable1DCylinderGeometryFactory | Geometry factory that creates Cylinders with given radius |
| CDeformable1DGeometryFactory | Geometry factory is an object that spawns geometries for a Deformable1D object |
| CDeformable1DInitializationReport | Initialization report kept in Deformable1D object for the user to check validity of the initial state |
| CDeformable1DIterator | |
| ►CDeformable1DNode | Special node implementation of segments in e.g., a Deformable1D object |
| CDeformationData | Structure containing relevant data for elasto-plastic deformation |
| ►CDeformable1DNodeRoute | Route the initial setup given nodes |
| CRouteData | |
| CDeformable1DPointRoute | Routing implementation where the user add 'points', i.e., orientation is neglected |
| CDeformable1DRadiusGeometryFactory | General geometry factory for shapes where width = height = radius |
| CDeformable1DRoute | Base class for routing algorithms holding all nodes and resolution |
| CDeformable1DSphereGeometryFactory | Geometry factory that creates Spheres with given radius |
| CDeformableMineFace | DeformableMineFace contains a agxCollide::HeightField |
| CDeformableParticleCreator | DeformableParticleCreator is a class used to generate granular material given the deformed volume in the specified DeformableMineFace |
| CDeformableParticleMesh | |
| CFractureAlgorithm | Class for encapsulating fracture conditions for generating fractures in a breakable object |
| CFractureAlgorithmBreakOnContact | |
| CFractureAlgorithmBreakOnContactForce | |
| CFractureAlgorithmBreakOnStress | |
| ►CFractureGenerator | |
| CContactFilter | |
| CFractureContactGatherer | FractureContactGatherer - Will gather relevant contact in the simulation, i.e. between breakers and breakable shapes |
| CNewBodyCallbackWrapper | Base Abstract class for encapsulating a callback that is executed on new fragments that are created in the fracture generator This class should be overridden to define how new fragments should be handled in the simulation |
| CNewBodyCallbackWrapperLambda | Class for encapsulating a lambda that that will execute on new fragments created in the fracture generator |
| CGaussianFunctionSettings | This struct holds parameters for the creation of a height texture that is a composite bump created by Gaussian height functions |
| CGaussianHeightMapGenerator | A height map generator using a Gaussian function |
| CGenericBeamModel | Generic beam model throwing exceptions for non-implemented virtual methods |
| CGenericBranchEventListener | Generic BranchEventListener throwing exceptions for non-implemented virtual methods |
| CGlobalTriangleData | Global triangle data (mapped with agxCollide::Mesh object) holding vertex indices |
| CGranularCustomBufferField | |
| CGranularField | Base class for a GranularField |
| CGranularFieldPostProcessor | Class for calculating different granular fields |
| CGranularMassField | |
| CGranularMomentumField | |
| CGranularVelocityField | |
| CHeightFieldDeformer | HeightFieldDeformer contains a agxCollide::HeightField |
| CHeightFieldDeformerJournalRecorder | Utility class used to record HeightFieldDeformer in an agx::Journal |
| CHeightMapGenerator | A base class used for generating textures |
| CHollowCircularBeam | Hollow circular cross section beam model with a given (outer) radius and thickness |
| CHollowRectangularBeam | Hollow rectangular cross section beam model with a given width, height and thickness |
| CHydrodynamicsParameters | |
| CIBeam | I-beam model with a given width, height, flange thickness and web thickness |
| CInternalDeformable1DData | Bridge between the InternalData system and the Deformable1D |
| CKinematicChain | A KinematicChain represents a chain consisting of multiple agx::RigidBody and agx::Constraint objects |
| CLiftForceAlgorithm | |
| CNodeAttachment | Base class for attachments to Deformable1D nodes |
| CNodeAttachmentT | Helper class to create give type of constraint for the different attachments |
| ►COneBodyTire | |
| CContactInfo | |
| CTireConstraintController | Class holding the constraints between ONE tire and an arbitrary number of other bodies |
| ►CPidController1D | A PID controller with the classic gain coefficients for proportional, integral, and derivative gain |
| CDerivative | Differentiate a PID controller signal with a two point estimation |
| CDerivativeFivePointStencil | Differentiate a PID controller signal with the "five-point stencil" method |
| CDerivativeThreePointSkewedStencil | Differentiate a PID controller signal with the "three-point stencil" method |
| CPlasticityComponent | Deformable1DComponent that adds plasticity to the deformable |
| CPointNodeAttachment | Node attachment using ball joint, i.e., the node will rotate about this attachment |
| CPressureDragForceAlgorithm | |
| CPressureFieldRenderer | |
| CRectangularBeam | Rectangular cross section beam model with a given width and height |
| CRigidNodeAttachment | Node attachment using lock joint, i.e., the node cannot move relative to this attachment |
| CRotatingNodeAttachment | Node attachment using hinge joint, i.e., the node can rotate about this attachment |
| CSegment | A Deformable1D segment is the segment between two nodes, or if this is the last segment, only one node but still has a start- and an end position defined |
| CSerialKinematicChain | A Serial Kinematic Chain is a KinematicChain where there are no loops or branches |
| CSingleCupSuctionGripper | |
| CSlidingNodeAttachment | Node attachment using prismatic joint, i.e., the node can slide along this attachment |
| CSuctionCup | |
| CSuctionCupInteraction | |
| CSuctionCupSensorFilter | Class for filtering objects of interest nearby a suction cup |
| CSuctionGripper | This should be considered a template class used as a base for Suction Gripper simulation models |
| CSurfaceVelocityConveyorBelt | This class models a conveyor belt using surface velocity |
| CThreeBodyTire | |
| CTire | |
| CTireFilter | |
| CTireFriction | Friction model that follows a tire's orientation in the world, based on the tire's frame |
| ►CTree | Tree is a structure of Branch objects in a mathematical Tree structure where a Branch can have several children Branches an so forth |
| CBranch | Branch is a part of the Tree, with a body and a constraint to its parent |
| CBranchEventListener | BranchEventListener handles certain events happening to a Tree |
| CTreeContactEventListener | |
| CTreeExecuteFilter | TreeExecuteFilter allows to catch contacts with the Tree |
| CTreeStepEventListener | |
| CTriangleData | Triangle data for a normal or a clipped triangle |
| CTwoBodyTire | |
| ►CUrdfReader | Class for reading a URDF file into an agxSDK::Assembly |
| CSettings | Settings for controlling details regarding the URDF reader |
| CVacuumSystem | Basic model for a vacuum system used by a SuctionGripper |
| CVertexData | Vertex data for all global vertices in a mesh |
| CViscousDragForceAlgorithm | |
| CWaterWrapper | Water wrapper that can be inherited to create custom made wrappers |
| ►CWindAndWaterController | Controller that collects relevant data and executes algorithms (probably mostly aero- and hydrodynamics) |
| CAerodynamicsData | |
| CDynamicsData | Data for rigid body with aero/hydro static/dynamic forces and added mass and inertia matrices |
| CDynamicsLinkedStructureData | Hydro- and aerodynamic results for a linked structure |
| CDynamicsWireData | Hydro- and aerodynamic results for a wire |
| CObjectData | Static data for a shape |
| CPressureFieldRendererData | |
| CSegment | |
| CUnitPrimitiveCache | |
| CWaterFlowGenerator | Interface for generating water flow |
| CWindAndWaterData | Data for different objects |
| CWindAndWaterFlowGenerator | Interface for generating water flow and wind |
| CWindGenerator | Interface for generating wind effects |
| CWindWrapper | Wraps wind related things |
| CWireLinkedStructureData | Data for a wire or a linked structure |
| CWirePair | |
| CWindAndWaterParameters | |
| ►NagxNet | Containins classes for sending/reading data over sockets as well as compression functionality |
| ►CCompress | Class for compressing data given a bit-stream |
| CData | |
| ►CCoSimulationBase | Base class for multi threaded transferring simulation between a server and a client using sockets |
| CHeader | Header used for sending data over sockets |
| CCoSimulationClient | Class for receiving serialized agxSDK::Simulation:s from remote host |
| CCoSimulationServer | Class for sending serialized agxSDK::Simulation over to a client |
| CFramePacket | |
| CIPAddress | Structure which holds IP address |
| CLibrary | Library singleton class |
| CNetError | Basic exception class |
| CPortRange | Handles testing of ports in a range |
| ►CRemoteDebugBase | Base class for multi threaded transferring simulation between a server and a client using sockets |
| CDataBlock | |
| CHeader | Header used for sending data over sockets |
| CRemoteDebugClient | Class for receiving serialized agxSDK::Simulation:s from remote host |
| CRemoteDebugServer | Class for sending serialized agxSDK::Simulation over to a client |
| ►CSocket | |
| CSystemIndependentSocketHandle | |
| CSocketSet | |
| CStructuredMessage | |
| CTCPServerSocket | |
| CTCPSocket | |
| CTcpSocketFrameReader | |
| CTcpSocketFrameWriter | |
| CTimeoutConnectError | Indicates a timeout between server/client |
| CUDPSocket | |
| ►Nagxopenplx | |
| CAgxCache | Cached AGX instances that are loaded by the AGX plugin |
| CAgxOpenPlxErrorFormatter | |
| CAgxOpenPlxErrorFormatterWrapper | Workaround for testing to avoid having to export the AgxOpenPlxErrorFormatter which is only used internally |
| CAgxPlugin | Openplx plugin for .agx and .aagx files, runs from openplx core api to process 'import "file.agx"'
or 'import @"file.aagx"' directives and convert them to .openplx code |
| CAgxToOpenPlxMapper | |
| CBundlePathHelper | |
| CClickAdapter | |
| CClickInputListener | Propagates Click input signals to openplx preFrame must be called continuously in main loop or similar |
| CClickKeyboardEventListener | |
| CClickOutputListener | Propagates output openplx signals to Click Messages |
| CEnsureUniqueId | |
| CFileChangedListener | |
| CInputSignalListener | Propagates input openplx signals to AGX |
| CInputSignalQueue | |
| CLoadResult | The return type of functions that load a .openplx file |
| CLogger | Used to setup the default logger for the agx-openplx DLL when using Shared Libraries on Windows |
| COpenPlxMaterialManager | |
| COpenPlxToAgxMapper | Maps OpenPLX objects to AGX objects |
| COpenPlxToOsgMapper | Maps OpenPLX objects to AGX OSG objects |
| COptParams | Model_name - if set a specific model from the source/file will be loaded instead of the default uuidv5_namespace_id - if set objects will be assigned version 5 UUIDs based on the namespace id and the object name instead of the default version 4 UUID |
| COsgClickAdapter | |
| COsgClickInputListener | Propagates Click input signals to openplx Inherits ExampleApplicationListener since Click messages can arrive even though the simulation is stopped |
| COutputSignalListener | Propagates output OpenPLX signals from AGX |
| COutputSignalQueue | |
| CSuctionCupStateToggler | |
| ►NagxOSG | The agxOSG namespace provides functionality for visualizing AGX simulations with OpenSceneGraph |
| CBoxProxy | Implementation of osg-based BoxProxy |
| CCableDamageDataRenderer | |
| CCableDamageRenderer | Class that creates OSG rendering nodes for each segment of a cable and colors them with a color gradient based on the current total damage estimate for the segment |
| CCameraData | |
| CCameraManipulatorFactory | |
| CCameraSynchronization | |
| CCapsuleProxy | Implementation of osg-based CapsuleProxy |
| CClipPlane | This class wraps the ClipPlane functionality of osg together with a clip node and a clip plane |
| CConeProxy | Implementation of osg-based ConeProxy |
| CContactProxy | Implementation of batch rendering of contact points |
| CContainerShapeBatchRenderer | Class that handles batch rendering of objects in forward iterator compliant container |
| CCylinderGeometryShader | |
| CCylinderProxy | Implementation of osg-based CylinderProxy |
| CDeformableHeightFieldRenderer | An osg-renderer for a deformable height field |
| CDeformableMeshUpdater | Updates a renderable representation of a deformable triangle mesh |
| CEmbeddedGLWindow | This class is for embedding an OSG based window inside another OpenGL contex, for example in QT |
| CExampleApplication | Class that encapsulates rendering and simulation using OpenSceneGraph |
| CExampleApplicationListener | |
| CExternalProcess | Cross-platform utility class for wrapping and launching external processes |
| CFilterContactByName | Filter that only accepts contacts where at least on of the bodes in the contact has a particular name |
| ►CForceArrowRenderer | Creates an arrow visualizing force, either contact force (for added bodies), or motor force for added Constraint1DOF (Hinge,Prismatic,..) |
| CBodyData | |
| CConstraintData | |
| CStatistic | |
| CFrameTrajectoryDrawable | |
| CGatherAvgPressure | |
| CGatherMaxPressure | |
| CGeometryNode | A node that can be associated with a collision geometry so that the transformation of this node is updated from the transformation of the Geometry |
| CGranularMergedBodyDrawable | |
| CGranularMergedBodyDrawableSprites | |
| ►CGraphRenderer | |
| COSGChannel | |
| CGuiEventAdapter | Class for inserting mouse and keyboard event from OSG into agxSDK::Simulation |
| CGuiEventListener | Derive from this class to implement a listener for simulation GuiEvents |
| CHeightField | Rendering class for the agxCollide::HeightField The visual representation will be updated if the HeightField is modified |
| CHeightFieldProxy | Implementation of osg-based HeightfieldProxy |
| CHollowCylinderProxy | Implementation of osg-based HollowCylinderProxy |
| CHollowTruncatedConeProxy | Implementation of osg-based HollowTruncatedConeProxy |
| ►CHudTextManager | HudTextManager is a class that inherits from agxSDK::StepEventListener and makes it easier to manipulate text in an agxOSG::SceneDecorator |
| CReferencedText | A class for having text elements with reference counting |
| CImageCapture | |
| ►CImageCaptureBase | |
| CImageVector | |
| CWriteImageThread | |
| ►CLidarOutputRenderer | Lidar point cloud renderer |
| CIntensityState | |
| CLightSource | |
| CLightsSynchronization | |
| CLineProxy | Implementation of osg-based LineProxy |
| CMeshExtractor | Store Vertices and indices as a vector in this class instance |
| CMeshExtractorReference | Store vertices and indices in vectors by reference |
| CNoTiltTrackballManipulator | |
| COSGData | Class for handling methods related to OSG such as setColor, setTransform etc |
| ►COsgTextureAtlasBuilder | |
| CAttemptsExhausted | |
| CPanel | |
| CParticleContactGraphDrawable | |
| CParticleSystemDrawable | |
| CParticleTrajectoriesDrawable | |
| CPickHandler | |
| CPlaneProxy | Implementation of osg-based PlaneProxy |
| CPlotsystemConstructor | |
| CPointSpriteDrawable | |
| CPressureAtlas | A pressure map for a single trimesh |
| CPressureAtlasManager | |
| CPressureFieldRenderer | |
| CPressureFromContacts | Generates pressure on a mesh from contacts |
| CPressureGenerator | Base class for types that want to supply force updates to a PressureAtlas |
| ►CPressureRenderer | An utility class for handling of pressure rendering and legend |
| CMaxAvgData | |
| CMaxAvgRecording | |
| CPressureToColorConverter | |
| CPressureToRgbaConverter | |
| ►CRenderProxyFactory | Implementation of the abstract class from the agxRender namespace, this class is responsible for creating RenderProxy of various types and render them as efficiently as possible in OpenSceneGraph |
| CShapeData | Class for storing OSG specific data for each RenderProxy |
| ►CRenderStateManager | |
| ►CRenderState | |
| CTexture | |
| CShaderState | |
| CRenderTarget | Render target is used for rendering camera content to a buffer, either a DEPTH or COLOR target |
| CRenderTaskDrawable | |
| CRenderToImage | This class will transfer the camera buffer to the CPU for local storage/processing |
| CRenderToTexture | |
| CRigidBodyBatchRenderProxy | Implementation of batch rendering of rigid body center of mass position |
| ►CRigidBodyRenderCache | RigidBodyRenderCache is used to cache generated visuals and lookup mappings of RigidBodies cloned from Templates in agx::RigidBodyEmitter and other related granular applications |
| CRigidBodyVisualGroup | A help class to store all information we need to copy a rigid body visualization to duplicate the rigid body from a rigid body template |
| CRigidBodySystemDrawable | |
| CRigidBodyTrajectoryDrawable | |
| CRockGenerator | |
| CScalarColorMap | Class that represents a linear scalar color map that converts a scalar interval to a specified color range |
| ►CSCCameraManipulator | SCCameraManipulator is base class for camera control based on focal center, distance from the center, and orientation of distance vector to the eye |
| COrbitAnimationData | |
| CSceneDecorator | Decorates a scene with a specific AGX Rendering Style |
| CSceneDescription | A pod-struct for holding information about scenes to load by the application |
| CShapeBatchRenderer | Base class for batch rendering of any shape or shape composite |
| CSimpleDepthBufferLidar | |
| CSimulationDrawable | |
| CSimulationPausedPrinter | SimulationPausedPrinter is a class that inherits from agxSDK::GuiEventListener and prints the simulation time to the hud |
| CSimulationSerializer | Class for serializing a simulation into a series for files on disk 0001_filename etc |
| CSimulationTimePrinter | SimulationTimePrinter is a class that inherits from agxSDK::GuiEventListener and prints the simulation time to the hud |
| CSkyBox | Sky box |
| CSoilParticleSystemDrawable | Internal drawable class for drawing the Voxel grid structure |
| CSphereProxy | Implementation of osg-based SphereProxy |
| CSplineRenderer | Class for rendering a spline model |
| CSplineRendererOld | |
| CSplineShader | Class to encapsulate reading shader files and setting up rendering of a Spline |
| CStatisticsRenderer | |
| ►CTerrainVoxelRenderer | Rendering class for the agxTerrain::Terrain |
| CContextData | |
| CSoilParticleMeshData | |
| CText | |
| ►CTextGeometry | Class for drawing simple/fast 2D text onto screen |
| CTextDrawCallback | |
| CTextProxy | Implementation of osg-based TextProxy |
| CTexture2D | |
| ►CTextureAtlasBuilder | |
| CAtlasCreationFailure | |
| CTransform | |
| CTree | |
| CTreeRenderer | |
| CTriangleExtractOperatorBase | This class is a base class that implements a functor, with a method triangle that is executed for each triangle visited |
| CTriangleExtractor | This class traverses a subgraph, accumulates transformations and execute a functor (TriangleExtractOperator per triangle |
| CTrimeshProxy | Implementation of osg-based TrimeshProxy |
| CTruncatedConeProxy | Implementation of osg-based TruncatedConeProxy |
| ►CVideoFFMPEGPipeCapture | |
| CCodecHash | |
| CWireRenderer | |
| CWireRendererOld | |
| CWireRenderProxy | |
| CWireShapeProxy | Implementation of osg-based WireShapeProxy |
| ►NagxPlot | Namespace contains functionality related to plotting |
| CBufferDataGenerator | |
| CCallbackDataGenerator | Callback class for generating data to be plotted |
| CCurve | Definition of a plot curve |
| ►CDataGenerator | Abstract base class for creating data to be plotted |
| CResult | |
| CDataListener | Event listener that will generate plotting data |
| CDataPacket | Package of points for a specified curve |
| CDataPoint | Definition of a data point |
| CDataSeries | Class that encapsulates data to be plotted, including methods for accessing the data, either via lambdas, Listeners or Uuid:s found in a simulation |
| CDataSeriesPacket | Package with a series of real values |
| CDebugPlot | "Static" helper class to plot values from where e.g., values aren't exposed |
| CDescriptionPacket | Class that describes a package with plot data |
| CFilePlot | Output definition that will write plot data to a file |
| CLambdaDataGenerator | |
| COnlyManualDataGenerator | |
| COutput | THis class wraps the description of data that should be plotted |
| CPacket | |
| CQueue | |
| CRealCallbackDataGenerator | Class that produces data in the form of a Real value |
| CScalarBufferDataGenerator | |
| ►CSystem | System that manages the plotting system |
| COutputThread | |
| CTimeDataSeries | Class for generating a data serie containg simulation time |
| CTimePacket | |
| CWindow | |
| ►NagxPowerLine | AgxPowerLine contains a collection of connected components that transport power across a system |
| ►Ndetail | |
| CAbstractDimensionState1Dof | Base class for the two one dimensional dimension state classes |
| CAbstractDimensionState3Dof | Base class for the two three dimensional dimension state classes |
| CConnectionIteratorOperations | |
| CConnectionIteratorTypes | |
| CConnectionIteratorTypes< Connector * > | |
| CConnectionIteratorTypes< const Connector * > | |
| CConnectionIteratorTypes< const PhysicalDimension * > | |
| CConnectionIteratorTypes< PhysicalDimension * > | |
| CConnectionOperations | |
| CDimensionState | A DimensionState is the data carrier of a PhysicalDimension |
| CDimensionState1Dof | Templated one dimensional dimension state |
| CDimensionState3Dof | Templated three dimensional dimension state |
| CElementaryWireWinchConnectorConstraint | Elementary constraint that connects a RotationalDimension in a PowerLine to the two PhysicalDimensions of a RigidBodyUnit |
| CPackingInfo | Information about which DimensionState1Dof is using which slot in a RigidBody |
| CPhysicalDimensionIteratorTypes | |
| CPhysicalDimensionIteratorTypes< const Unit * > | |
| CPhysicalDimensionIteratorTypes< Unit * > | |
| CRigidBodyRotationalAttachmentSentry | RigidBodyTranslationalAttachment has been deprecated and removed |
| CRigidBodyTranslationalAttachmentSentry | RigidBodyTranslationalAttachment has been deprecated and removed |
| CRotational | RigidBody accessor helper that knows how to extract rotational data from a RigidBody |
| CSlotMapperUnitTestEntryPoint | The UnitTestEntryPoint is a backdoor into the SlotMapper's internal state used by the unit tests to ensure that the SlotMapper implementation is correct |
| CTranslational | RigidBody accessor helper that knows how to extract translational data from a RigidBody |
| CWireWinchConnector | |
| CWireWinchConnectorConstraintImplementation | |
| CAbstractPowerLineTraverser | Base class for all power line traversers |
| CActuator | Abstract base class for connecting a agxPowerLine::Unit to an ordinary constraint such as a Hinge or Prismatic |
| ►CActuator1DOF | An Actuator that operates on Constraint1DOF constraints |
| CConstraintObserver | Observer that not only sets the Constraint pointer to nullptr on object deletion, but also informs the owning Actuator so the body units can be updated |
| CActuatorBodyUnit | An ActuatorBodyUnit forms a connection between the power line world and the rest of the simulation |
| CActuatorConnector | |
| CActuatorConstraintImplementation | |
| CActuatorDimension | |
| CActuatorRotationalDimension | |
| CActuatorTranslationalDimension | |
| CConnection | |
| CConnectionIterator | Iterator that iterates over all, both input and output, connections that have a non-null Connector |
| CConnector | Links two connections together |
| CConstraint1DOFGeometry | ConstraintGeometry for 1-DOF constraints |
| CConstraintGeometry | Description of how an Actuator is allowed to apply forces and torques on the body or bodies attached to the actuated constraint |
| CControllerConstraintGeometry | ConstraintGeometry for any type of constraint that has a BasicControllerConstraint along the axis that the Actutar should operate |
| ►CDotGraphWriter | |
| CSeenSubGraph | |
| CElementaryActuatorConstraint | |
| CElementaryGearConstraint | An elementary gear constraint constrains the velocity of the rotational dimensions of a number bodies |
| CElementaryHolonomicGearConstraint | An elementary gear constraint constrains the velocity of the rotational dimensions of a number bodies |
| CElementaryPhysicalDimensionConstraint | Pure virtual function |
| CElementaryPhysicalDimensionMultiBodyConstraint | Elementary constraint for constraining an arbitrary number of ONE specific PhysicalDimension::Type |
| CElementaryTranslationalConstraint | |
| CGearConstraintImplementation | Constraint implementation that constrains the velocity of the rotational dimensions of a number bodies |
| CHolonomicGearConstraintImplementation | Constraint implementation that constrains the velocity of the rotational dimensions of a number bodies |
| CLinearLookupTable | Linear interpolation between the inserted variable/value pairs |
| CLookupTable | Return a value of y given any value of x |
| CPhysicalDimension | Pure virtual class |
| CPhysicalDimensionIterator | Iterator that iterates over the non-null PhysicalDimensions of a Unit |
| CPhysicalDimensionMultiBodyConstraintImplementation | Constraint implementation for constraining a number of physical dimensions of the same type |
| CPowerGenerator | Will generate power by adding a load to a physical dimension |
| CPowerLine | PowerLine is the base class for a system of power transfer integrated into the rigid body simulation |
| CPowerLineCallbackTraverser | Traverser that calls a user supplied callback in its 'visit' methods |
| CPowerLineCollector | PowerLineTraverser that stores the nodes it visits |
| CPowerLineConstTraverser | Template specialization for const traversal |
| CPowerLineController | Each type of physical dimension handled by the power line has to have a unique name |
| CPowerLinesHandler | A PowerLinesHandler is a collection of PowerLines that are part of the same agxSDK::Simulation |
| CPowerLineTraverser | Template specialization for non-const traversal |
| CPowerTimeIntegralLookupTable | A lookup table used for power time integral (torque for rotational power, force for translational power) |
| CRotationalActuator | Class that will connect a agxPowerLine::Unit to a rotational ordinary constraint such as a agx::Hinge |
| CRotationalConnector | Defines a stiff gear constraint between two rotational dimensions |
| CRotationalDimension | The rotational has one rotational degree of freedom |
| CRotationalTranslationalConnector | Constrains a rotational degree of freedom with a translational degree of freedom with a non-holonomic constraint |
| CRotationalTranslationalHolonomicConnector | This class can be used to connect the position of a rotational and a positional unit |
| CRotationalUnit | A rotational unit has one degree of freedom |
| CSlotMapper | The SlotMapper is reponsible for mapping one dimensional dimension states to slots in the RigidBodies |
| CStepEventDotGraphWriter | A StepEventListener that writes a power line.dot graph in the LAST event |
| CSubGraph | |
| CTorqueGenerator | A torque generator adds torque to the body of a rotational dimension |
| ►CTranslationalActuator | Class that will connect a agxPowerLine::Unit to a translational ordinary constraint such as a agx::Prismatic |
| Cdont_create_input_t | |
| CTranslationalConstraintImplementation | |
| CTranslationalUnit | |
| CUnit | Pure virtual class |
| CWireWinchActuator | This actuator can be used to connect a Winch (which is a linear constraint) to a powerline for example a rotating shaft |
| ►NagxRender | Namespace containing classes for handling debug rendering of collision geometries, constraints, contacts and rigid bodies |
| CBoxProxy | Subclass that implements a BoxProxy |
| CCapsuleProxy | Subclass that implements a CapsuleProxy |
| CColor | Utility color class with "common colors" |
| CConeProxy | Subclass that implements a ConeProxy |
| CContactsProxy | Class holding contacts that makes it possible to batch render these objects |
| CCylinderProxy | Subclass that implements a CylinderProxy |
| ►CGraph | Class that implements a simple graph for plotting scalar values |
| CChannel | Internal class for handling data for a channel |
| CGraphRenderer | Abstract base class that acts as an interface and can render the data from a Graph |
| CHeightFieldProxy | Subclass that implements a HeightfieldProxy |
| CHollowCylinderProxy | Subclass that implements a CylinderProxy |
| CHollowTruncatedConeProxy | Subclass that implements a HollowTruncatedConeProxy |
| CLineProxy | Subclass that implements a LineProxy |
| CPlaneProxy | Subclass that implements a PlaneProxy |
| CRenderable | Inherit from this class and implement the render() method to make it it self during debug rendering |
| ►CRenderManager | Class for managing the rendering of geometries, shapes, rigid bodies, constraints etc |
| CCacheBase | |
| CPrimitiveCache | Class for storing RenderProxies that are currently in use |
| CPrimitiveCache1 | Class for storing RenderProxies that are currently in use |
| CRenderProxy | Abstract base class which encapsulated information for rendering a specific shape |
| CRenderProxyFactory | Abstract class which is responsible for returning a pointer to a specified RenderProxy type |
| ►CRenderSingleton | Utility class for creating debug rendering objects |
| CFrame | |
| CLine | Defines a Line to be used in DebugRendering |
| CPoint | Defines a point to be used in DebugRendering |
| CText | Defines Text to be used in DebugRendering |
| CTriangle | Defines a Triangle to be used in DebugRendering |
| CRigidBodyBatchRenderProxy | Class holding rigid bodies that makes it possible to batch render these objects |
| CSpaceListener | A listener that will be responsible for calling RenderManager every time a Shape is added/removed from space |
| CSphereProxy | Subclass that implements a SphereProxy |
| CTextProxy | Subclass that implements a TextProxy |
| CTrimeshProxy | Subclass that implements a TrimeshProxy |
| CTruncatedConeProxy | Subclass that implements a TruncatedConeProxy |
| ►CWireRenderProxy | |
| CSegmentDef | |
| CSphereDef | |
| CWireShapeProxy | Subclass that implements a WireShapeProxy |
| ►NagxROS2 | |
| ►NagxMsgs | |
| CAny | |
| CAnySequence | |
| ►NbuiltinInterfaces | |
| CDuration | |
| CTime | |
| ►NgeometryMsgs | |
| CAccel | |
| CAccelStamped | |
| CAccelWithCovariance | |
| CAccelWithCovarianceStamped | |
| CInertia | |
| CInertiaStamped | |
| CPoint | |
| CPoint32 | |
| CPointStamped | |
| CPolygon | |
| CPolygonStamped | |
| CPose | |
| CPose2D | |
| CPoseArray | |
| CPoseStamped | |
| CPoseWithCovariance | |
| CPoseWithCovarianceStamped | |
| CQuaternion | |
| CQuaternionStamped | |
| CTransform | |
| CTransformStamped | |
| CTwist | |
| CTwistStamped | |
| CTwistWithCovariance | |
| CTwistWithCovarianceStamped | |
| CVector3 | |
| CVector3Stamped | |
| CWrench | |
| CWrenchStamped | |
| ►NrosgraphMsgs | |
| CClock | |
| ►NsensorMsgs | |
| CBatteryState | |
| CCameraInfo | |
| CChannelFloat32 | |
| CCompressedImage | |
| CFluidPressure | |
| CIlluminance | |
| CImage | |
| CImu | |
| CJointState | |
| CJoy | |
| CJoyFeedback | |
| CJoyFeedbackArray | |
| CLaserEcho | |
| CLaserScan | |
| CMagneticField | |
| CMultiDOFJointState | |
| CMultiEchoLaserScan | |
| CNavSatFix | |
| CNavSatStatus | |
| CPointCloud | |
| CPointCloud2 | |
| CPointField | |
| CRange | |
| CRegionOfInterest | |
| CRelativeHumidity | |
| CTemperature | |
| CTimeReference | |
| ►NstdMsgs | |
| CBool | |
| CByte | |
| CByteMultiArray | |
| CChar | |
| CColorRGBA | |
| CEmpty | |
| CFloat32 | |
| CFloat32MultiArray | |
| CFloat64 | |
| CFloat64MultiArray | |
| CHeader | |
| CInt16 | |
| CInt16MultiArray | |
| CInt32 | |
| CInt32MultiArray | |
| CInt64 | |
| CInt64MultiArray | |
| CInt8 | |
| CInt8MultiArray | |
| CMultiArrayDimension | |
| CMultiArrayLayout | |
| CString | |
| CUInt16 | |
| CUInt16MultiArray | |
| CUInt32 | |
| CUInt32MultiArray | |
| CUInt64 | |
| CUInt64MultiArray | |
| CUInt8 | |
| CUInt8MultiArray | |
| CAnyMessageBuilder | AnyMessageBuilder is a helper class for serializing custom data structures to an agxMsgs::Any message type that can then be sent via ROS2 and deserialized using the AnyMessageParser |
| CAnyMessageParser | AnyMessageParser is a helper class for deserializing agxMsgs::Any back to the original custom data type that was created using the AnyMessageBuilder |
| CPublisher | Publisher class that enables sending ROS2 messages |
| CQOS | Struct containing Quality of Service (QOS) settings |
| CROS2ClockPublisher | |
| CROS2ControlInterface | Possible to add joints (Constraint1DOF) and the listener will publish the position and velocity for the joints as a sensorMsgs/JointState aswell as listens to commands to control said joint |
| CSubscriber | Subscriber class that enables receiving ROS2 messages |
| ►NagxSDK | The agxSDK namespace contain classes to bridge the collision detection system and the dynamical simulation system including Material, event listeners etc |
| ►NMergeSplitUtils | |
| CExternalForceSplitResult | |
| CWireSegmentMergedState | Wire merged state segment along a wire |
| CAssembly | An assembly is a collection of basic simulation objects, such as rigid bodies, constraints, geometries |
| CAssemblyVisitor | Class for visiting all elements in a tree of Assemblies |
| CBoolPropertyFilter | Class for matching bool properties |
| CCollection | A Collection is a collection of basic simulation objects, such as rigid bodies, constraints, geometries |
| CCollisionGroupFilter | An ExecuteFilter that is used to filter out contacts matching a specified criteria based on Collision groups |
| CConstraintEnergyData | |
| CConstraintLogListener | Class that will log various properties of constraints |
| CConstraintMergedState | |
| ►CConstraintMergeSplitAlgorithm | |
| CComputeData | |
| CPostSolveComputeData | |
| CPostSolveComputeExData | |
| CConstraintMergeSplitThresholds | Specific thresholds used to split and merge objects given constraints |
| CContactEventListener | Derive from this class to implement a listener for Collision events |
| CContactFilterReducerListener | Class that execute the agxCollide::ContactReducer::reduce on contact points that are collected via a specific ExecuteFilter |
| CDoublePropertyFilter | Class for matching double properties |
| CEnergyManager | Keeps track of the energy flow in the system |
| CEventListener | An EventListener can be associated to a Simulation and triggered upon various events |
| CExecuteFilter | Abstract base class that implements a filter that selects which events should trigger a Listener |
| CExecuteFilterT | Templated version of ExecuteFilter, for objects which contain geometries and inherit from agx::Referenced, such as agxCollide::Geometry, agx::RigidBody, or agxSDK::Assembly |
| CFloatPropertyFilter | Class for matching float properties |
| CFrictionModelFilter | Execute filter matching friction model instance of the geometry contact |
| ►CGeometryContactMergeSplitAlgorithm | |
| CComputeData | |
| CGeometryContactMergeSplitThresholds | Specific thresholds used to merge and split given geometry contacts |
| CGranularContactMergeSplitAlgorithm | |
| CGuiEvent | Class for storing an Event which will be executed later inside Simulation |
| CGuiEventAdapter | Base class for inserting mouse and keyboard event into agxSDK::Simulation |
| CGuiEventListener | Derive from this class to implement a listener for simulation GuiEvents |
| CIntPropertyFilter | Class for matching int properties |
| CISensorEnvironment | Interface to a cooperative sensor simulation assumed to be executed in a separate thread spawned in addNotification and joined in removeNotification |
| ►CKinematicPathListener | Class that will update a rigid body's transformation and velocities based on a given path of transformations and time stamps |
| CPathConfiguration | Help struct for storing transformation data per time step |
| CLineContactEdge | |
| CLineContactPosition | |
| CLinkedSegment | Segment object in a linked structure |
| CLinkedSegmentIterator | Optionally unbounded linked structure segment iterator object to iterate segments in a SegmentStructure |
| CLinkedSegmentRange | Segment range object for linked structure |
| ►CLinkedStructure | Basic implementation of any structure where bodies are linked/constrained together in a well defined consecutive order |
| CIdData | Group id 'union' of int id and name id |
| CLinkedStructureComponent | Base implementation of a component (e.g., specific functionality) in linked structures |
| CLinkedStructureObjectData | Connection back from bodies, constraints etc |
| CLogListener | Abstract class for logging properties per time step to a file/standard out |
| CLongPropertyFilter | Class for matching Long int properties |
| ►CMaterialManager | Simulation unique manager that handles logics around and parameters in contact materials given two agx::Materials |
| CMaterialManagerSerializer | Internal class for store/restore of MaterialManager |
| ►CMergedBodyMergeSplitAlgorithm | |
| CPostSolveMergedBodySolverData | |
| ►CMergedBodySolverData | Collection of external (active) interactions, interacting with merged rigid bodies |
| CForceData | Object containing force and torque from a graph node |
| CForceFrame | Force frame where the resultant force is u + v + n |
| CMergedState | Object holding merged bodies and state given a pair of rigid bodies |
| CMergeIgnoreFilter | A collection of merge ignore group ID pairs for which merge should be rejected |
| CMergeIgnoreGroups | A collection of merge ignore groups, some named and some not |
| CMergeSplitAction | Data for merge or split actions created in an implementation of an agxSDK::MergeSplitAlgorithm |
| CMergeSplitActionContainer | Object containing merge-split actions to be processed by the agxSDK::MergeSplitHandler |
| CMergeSplitAlgorithm | Stateless base class for merge and split of interactions |
| CMergeSplitHandler | Base class for a merge split algorithm handling a set of merged bodies |
| CMergeSplitParallelRaContainerKernel | |
| CMergeSplitParallelReferencedDataKernel | |
| CMergeSplitPostSolveData | |
| CMergeSplitProperties | |
| CMergeSplitThresholds | Base class for thresholds/constants/values used in agxSDK::MergeSplitAlgorithm |
| CMultiCollisionFilterContactHandler | A step event listener managing N contact event listeners with different filters |
| ►CPickHandler | |
| CPickedParticle | |
| CPickResult | |
| CPropertyFilter | A class for filtering contacts based on the geometries' properties (as in: their property container) |
| CRigidBodyLogListener | Class that will log various properties of rigid bodies |
| CSimulation | Simulation is a class that bridges the collision space agxCollide::Space and the dynamic simulation system agx::DynamicsSystem |
| ►CSimulationControl | A class for adding input and output arguments, to be used when running a co-simulation |
| CInputArgumentCollection | |
| COutputArgumentCollection | |
| CSimulationControlArgument | Base class for input/output arguments |
| ►CSimulationFrameReader | |
| CArchiveEvent | |
| CDataBinding | |
| CDirtySet | |
| CSimulationFrameWriter | |
| CSimulationObject | Deprecated, used only for internal examples* |
| CSimulationParameter | |
| CSimulationParameterT | |
| CSimulationProxy | Interface class used by internal objects running in parallel |
| CSimulationSerializer | Class for serializing a simulation into a series for files on disk <filename>_0001.agx etc |
| CSimulationStatisticsListener | This class will collect statistics and sizes of a simulation |
| CStatisticsData | Store all the various statistics of a simulation |
| CStatisticsEntries | |
| CStatisticsListenerData | Class for storing min/max values together with a ID for the associated RigidBody/Geometry |
| CStepEventListener | Derive from this class to implement a listener for simulation step events |
| CStringPropertyFilter | Class for matching bool properties |
| CTerrainInstance | AgxTerrain::Terrain instance in a simulation, receiving step and contact callbacks in a controllable way to avoid interference with user step and contact callbacks |
| CTerrainToolInstance | An agxTerrain::TerrainToolInstance in a simulation, receiving step and contact callbacks in a controllable way to avoid interference with user step and contact callbacks |
| CUuidHashCollisionFilter | Contact event filter matching UUID of instances, such as agxCollide::Geometry, agx::RigidBody, agxWire::Wire, agxCable::Cable, agxVehicle::Track and/or agxTerrain::Terrain |
| ►CWireMergeSplitAlgorithm | |
| CPostSolveData | |
| CWireMergeSplitThresholds | Specific thresholds used to split and merge objects given wires |
| ►NagxSensor | The agxSensor namespace contains components to model real-time sensors connected to the physics of AGX Dynamics |
| CAccelerometer | Accelerometer instance class defined by a frame/transform and a model |
| CAccelerometerModel | Base accelerometer model describing the fundamental parameters, such as measurement range and zero bias, of an accelerometer |
| CAccelerometerOutputHandler | Handler responsible for how the accelerometer readings are assembled and provided to the user |
| CAccelerometerSignalAssembler | Assembles the initial unmodified accelerometer signal |
| CBinaryOutputBuffer | Buffer used for sensor output of a wide range of output element types |
| ►CBinaryOutputView | View for reading sections of a binary packed buffer of the specified template parameter type |
| Citerator | |
| CDipoleMagneticField | A magnetic field as produced by a magnetic dipole |
| CEnvironment | Sensor environment implementation where different sensors collects data given a set of added objects, such as rigid bodies, geometries, shapes, wires, cables, terrains, etc |
| CFrameAttachedSensor | Common base type for all sensors attached to a frame of reference, such as that of a rigid body |
| CGyroscope | Gyroscope instance class defined by a frame/transform and a model |
| CGyroscopeLinearAccelerationEffects | Applies an offset to the zero rate bias depending on the linear acceleration that the gyroscope is exposed to |
| CGyroscopeLinearAccelerationEffectsNode | Instance proxy node for storing the state information need by the gyroscope linear acceleration effects |
| CGyroscopeModel | Base gyroscope model describing the fundamental parameters, such as measurement range and zero bias, of a gyroscope |
| CGyroscopeOutputHandler | Handler responsible for how the gyroscope readings are assembled and provided to the user |
| CGyroscopeSignalAssembler | Assembles the initial unmodified gyroscope signal |
| CIMU | Inertial measurement unit (IMU) instance class defined by a frame/transform and a model |
| CIMUModel | IMU model describing which sensors are attached on this certain kind of IMU |
| CIMUModelAccelerometerAttachment | Accelerometer sensor attachment onto an IMU model |
| CIMUModelGyroscopeAttachment | Gyroscope sensor attachment onto an IMU model |
| CIMUModelMagnetometerAttachment | Magnetometer sensor attachment onto an IMU model |
| CIMUModelSensorAttachment | Base type for specifying sensor attachments onto an IMU model |
| CIMUModelSensorAttachmentSensorAttachment | Specification of a sensor attachment onto the IMU |
| CIMUOutput | IMU sensor output data where IMUOutput::Field is used to define the data available |
| CIMUOutputHandler | Handler responsible for how the IMU readings are assembled and provided to the user |
| CIRtSystemNode | Interface as RtSystemNode for model specific implementations that is part of the system tree of lidar instances |
| CISensorOutput | Common interface for sensor output data |
| CISensorOutputHandler | Common interface for sensor output handlers |
| CISystemNodeProxy | Interface for system node behavioral implementations intended to have multiple states/instances (SystemNodeProxy/ies) in the system graph |
| CITriaxialSignalCarrier | Interface for types carrying a triaxial signal |
| CITriaxialSignalNoiseNode | Interface for implementation details for triaxial signal system nodes carrying a random noise generator |
| CITriaxialSignalSystemNode | Interface for implementation details for system nodes carrying a triaxial signal |
| CLidar | Lidar instance class defined by a frame/transform and a model |
| CLidarFrameNode | Lidar rays to world transform node |
| CLidarModel | Base lidar model describing the fundamentals, such as ray pattern, range and beam properties, of a lidar |
| CLidarModelGeneric360HorizontalSweep | A simple 360 degree sweeping lidar model of a vertical field of view of +/- 50 degrees and a resolution of 0.5 degrees in both the vertical and horizontal axis |
| CLidarModelGeneric360HorizontalSweep10Hz | A very simple short-hand for creating a basic 360 degree horizontally sweeping lidar locked at the common lidar scanning frequency of 10 Hz |
| CLidarModelHorizontalSweep | A lidar model defining a rotational lidar, scanning its surroundings by emitting racks of laser beams in a circular pattern around the lidar, based on a horizontal field of view |
| CLidarModelMechanicalRotation | Model of lidar that rotates laser emitter / reciever assembly continuously, with a given rotational frequency, vertical range, lidar ray range and horizontal / vertical resolution |
| CLidarModelOusterOS | Simulation implementation of the Ouster OSx lidar model series - OS0, OS1, OS2 |
| CLidarModelOusterOS0 | Specialized class for the Ouster OS0 lidar model |
| CLidarModelOusterOS1 | Specialized class for the Ouster OS1 lidar model |
| CLidarModelOusterOS2 | Specialized class for the Ouster OS2 lidar model |
| CLidarProperties | Properties/parameters of a lidar model |
| CLidarRayAngleGaussianNoise | Gaussian distributed perturbation of lidar ray emission and detection angle |
| CLidarRayDistortion | Base type for distortions applied to the lidar rays before raytrace |
| CLidarRayDistortionHandler | Ray noise handler is responsible for all distortion application to rays before raytrace |
| CLidarRayPatternGenerator | Base of lidar ray pattern implementations resposible of providing a set of ray transforms (ray along z) and an interval each tick indexing into the set of ray transforms |
| CLidarRayPatternHorizontalSweep | Horizontal sweep pattern containing a full revolution of transforms, given field of view and resolution |
| CLidarRayPatternInterval | Ray pattern interval (index range) with a start index and size |
| CLidarRayPatternSingleRay | Ray pattern with only one single ray along the local z-axis of the Lidar using it |
| CLidarRayRange | Start and end range of each lidar ray, default [0, "infinity") |
| CMagneticField | Base type for the specification of the magnetic field in a sensor environment |
| CMagnetometer | Magnetometer instance class defined by a frame/transform and a model |
| CMagnetometerModel | Base magnetometer model describing the fundamental parameters, such as measurement range and zero flux bias, of an magnetometer |
| CMagnetometerOutputHandler | Handler responsible for how the magnetometer readings are assembled and provided to the user |
| CMagnetometerSignalAssembler | Assembles the initial unmodified magnetometer signal |
| CRtAmbientMaterial | Ambient homogeneous atmospheric material attenuating the light and producing stochastic returns in the atmosphere |
| CRtBrdfExplicitMaterial | Opaque surface material reflecting the light according to an explicitly specified bidirectional reflectance distribution function (BRDF) |
| CRtConfig | Utility functions used for configuration of the lower level raytracing functionality of agxSensor |
| CRtDistanceGaussianNoise | This node applies a distance noise with gaussian distribution to the Lidar output data |
| CRtGgxAndOrenNayarMaterial | Opaque surface material reflecting light according to the combined two-layer model with a specular GGX microfacet top-layer and a second microfacet Oren-Nayar diffuse layer |
| CRtLambertianOpaqueMaterial | Opaque surface material reflecting the light according to the Lambertian model of diffuse reflectance |
| CRtMaterial | Base type for all surface, and transmission, materials used in raytracing |
| CRtMaterialHandle | Material handle of implicit type in the raytrace environment |
| CRtMaterialInstance | Material instance in the raytrace environment, containing handle and type |
| CRtNode | A node performs a single operation, e.g., raycast, gaussian blur, merging etc |
| CRtNodeGroupHandler | This node doesn't have a representation in the raytrace graph but manages adding and removal of children when this nodes parent is varying/optional |
| ►CRtOutput | Raytrace output data where RtOutput::Field defines the data available |
| CDataState | |
| CRtOutputHandler | Raytrace result handler is resposible for when and how the raytracing starts and ends and collecting/fetching data |
| CRtOutputNoise | Defines a noise that is applied to Lidar output data |
| CRtRegistry | Registry allowing value storage mapped to raytrace entities |
| CRtRemoveRayMisses | This node will remove data from rays that doesn't hit any target |
| CRtScene | Raytrace scene with handle and ambient/atmospheric material |
| CRtSceneHandle | A scene constitutes the raytrace environment and contains a number of raytrace instances |
| CRtShape | Handle and interface for shapes in the raytrace environment (alias RtShapeHandle) |
| CRtShapeCollisionShapeSystem | Raytrace system representing agxCollide::Shape instances as mesh(es) in the raytrace environment |
| CRtShapeInstance | Raytrace shape instance data with a handle to the dito on the GPU, data and shape (ref-counting so that it's released when no instances uses the shape) |
| CRtShapeInstanceHandle | Handle to an instance in the raytrace environment |
| CRtShapeLinkedStructureSystem | Raytrace system representing agxSDK::LinkedStructure (agxCable::Cable, agxVehicle::Track agxModel::Beam, ...) instances as shapes in the raytrace environment |
| CRtShapeTerrainPagerSystem | Raytrace system handling paged agxTerrain::Terrain instances |
| CRtShapeTerrainSystem | Raytrace system handling agxTerrain::Terrain instances |
| CRtShapeTerrainSystemBase | Base raytrace system handling ordinary and paged agxTerrain::Terrain instances |
| CRtShapeWireSystem | Raytrace system representing agxWire::Wire instances as meshes in the raytrace environment |
| CRtStorage | Storage vector mapping entity ID:s to corresponding values of the specified template type |
| CRtSurfaceMaterial | Surface material of shape instances in the raytrace environment |
| CRtSystemNode | A system node focused on raytracing |
| CRtSystemNodeProxy | Raytrace system node acting as a clone of model specific implementations |
| CSensor | Common base type for all sensors sharing the same general agxSensor layout |
| ►CSystemNode | System node is a separate step/operation in an execution tree representing a sensor (or such) in a sensor simulation environment |
| CCallbackData | |
| CSystemNodeProxy | Proxy system node, representing an instance of an ISystemNodeProxy in the system graph |
| CTriaxialCrossSensitivity | Specification of cross sensitivity between tree axis |
| CTriaxialGaussianNoise | Applies a total Gaussian noise to the triaxial signal based on a specified noise RMS |
| CTriaxialOutput | Triaxial sensor output data where TriaxialOutput::Field is used to define the data available |
| CTriaxialOutputHandler | Common base type for triaxial sensor output handlers |
| CTriaxialRange | Range specification along three axis |
| CTriaxialSignalNoiseNode | A system node in the sensor processing tree carrying a triaxial signal, a random noise generator and an implementation for how to apply the noise |
| CTriaxialSignalScaling | Applies a constant scaling to the triaxial signal |
| CTriaxialSignalSystemNode | A system node in the sensor processing tree carrying a triaxial signal and an implementation for how to process it |
| CTriaxialSpectralGaussianNoise | Applies Gaussian noise to the triaxial signal based on a specified noise spectral density and the sample frequency of the signal |
| CUniformMagneticField | A magnetic field with equal direction and strength across the entire sensor environment |
| ►NagxStream | This namespace contain classes for streaming classes into archives, ASCII, binary for storage (serialization) |
| ►CArchive | Abstract base class for input/output storage of Serializable classes |
| CScopedSection | Ties a beginSecion/endSection pair to a scope |
| CArchiveEofException | |
| CArchiveException | |
| CClassInformation | Class that extracts namespace, class name and method name when called with the AGX_FUNCTION macro |
| CEndOfArchiveException | |
| CInputArchive | Class for reading a binary stream of serialized data |
| CInputRef | |
| CInputVal | |
| ►COutputArchive | Class for writing serialized data in binary format to a stream |
| CIdEntry | |
| CObjectToIdMapContext | This struct is used to handle id-collisions when using incremental journal |
| COutputRef | |
| COutputVal | |
| CRestoreListener | Class for listening to the restore of Serializable objects |
| CRestoreObjects | |
| CSerializable | This class is an abstract base class for all classes that can be stored and retrieved from an Archive |
| CSerializablePtrVector | |
| ►CStorageStream | Abstract base class for storing/restoring a line/drums with version control |
| CScopedBlock | Ties a beginBlock/endBlock pair to a scope |
| CStoreObjects | |
| ►CXMLInputArchive | XML version of an input archive for restoring data written with the XMLOutputArchive |
| CStackElement | |
| CXMLOutputArchive | XML version of an OutputArchive (for storing serialized objects) |
| ►NagxTerrain | The agxTerrain namespace contains a 3D model for a dynamic deformable Terrain and related classes |
| ►Ndeprecated | |
| CTerrainToolCollection | Collection of terrain tool (currently Shovel) related objects which are terrain instance specific |
| ►NGroundCollapse | |
| CCollapseRenderSettings | |
| CCollapseSettings | |
| CContactData | |
| CContactResult | |
| CFailureSurface | |
| CFailureSurfaceAggregate | |
| CFailureSurfaceResult | |
| CGroundCollapseController | |
| CGroundCollapseResult | |
| CLoadPoint | |
| CSubStepResult | |
| CActiveZone | |
| CActiveZoneIntersectionData | |
| CAdvancedShovelSettings | |
| CAggregateContactDepthModel | Class used to calculate the contact depth in the soil aggregate <-> terrain contacts to mimic an elasto-plastic contact model |
| CAggregateContactGenerator | |
| CBasicGrid | Pure virtual interface class for the data storage grid classes we have |
| CClamShellBucket | ClamShellBucket is a CompositeShovel class that models a clamshell bucket that consists of two opposing shovels |
| CColumnHeightGrid | Class implementing the BasicGrid interface |
| CCompactionController | Controller that handles compaction in the terrain from generated terrain contacts in TerrainContactGenerator The controller features two methods that calculate stress depth propagation in the terrain soil: BOUSSINESQ - Two part method that calculates the stress field by combining the calculated surface stress and subsoil stress based on the surface contact point loads |
| CCompositeShovel | CompositeShovel is a base abstract class representation of Shovels types that consists of multiple child Shovel instances |
| CDeformController | |
| CDeformerActiveZone | |
| CDeformerCollection | |
| CExternalTerrainDataSource | This class provides a concrete, serializable base class which classes written in other languages can inherit from to create data sources |
| CForbiddenBound | Class for specifying a 3D bound where terrain operations like merging and avalanching is forbbiden |
| CForbiddenIndex2DBound | Class for specifying a 2D terrain index bound where terrain operations like merging and avalanching is forbbiden |
| CForbiddenIndexBound | Class for specifying a 3D terrain index bound where terrain operations like merging and avalanching is forbbiden |
| CGrid | Extended pure virtual interface for Grid storage classes |
| CGridElement | |
| CHashVoxelGrid | Class implementing the BasicGrid interface |
| CIForbiddenBound | Base abstract class for specifying different types of bounds bound where terrain operations like merging and avalanching is forbbiden |
| CPointData | |
| CPrimaryActiveZone | |
| CScopeReportSystemJob | |
| CScopeTimer | |
| ►CShovel | Shovel object used to interact with a terrain via an active zone that converts solid terrain to dynamic terrain which can be moved by the shovel rigid body |
| CExcavationSettings | Class containing the settings for the different ExcavationModes for a shovel |
| CSoilPenetrationParameters | |
| CTeethSettings | |
| CShovelAggregateContactMaterialContainer | Simple container class for storing and handling explicit contact material for shovel-aggregate contacts, indexed by specified excavation mode |
| CShovelAggregateFrictionModel | |
| CShovelSettings | |
| CShovelUtils | |
| CSoilParticleAggregate | |
| CSoilParticleStatistics | |
| CSoilPenetrationResistance | |
| CSoilSimulationInterface | Interface class for accessing data and functions for the internal soil particle simulation used in agxTerrain |
| CSoilWedge | |
| ►CTerrain | A terrain model based a 3D grid model with overlapping height field that can be deformed by interacting shovels objects performing digging motions, converting solid mass to dynamic mass which can be moved |
| CoffsetIndexInfo | |
| CTerrainCache | The TerrainCache is used internally by the TerrainPager to provide requested terrain tiles |
| ►CTerrainContact | Class that contains information about a terrain contact between an external object and the terrain geometry |
| CSurfaceForce | Struct holding information about a surface force of the Terrain contact |
| CTerrainContactGenerator | This class has two main responsibilities: |
| CTerrainDataSource | Abstract interface for requesting height data for a Terrain tile |
| CTerrainGridControl | Interface class for accessing and manipulating the underlying 3D grid data in the terrain using terrain index (x,y) as well as depth index (z) |
| CTerrainJournalRecorder | |
| CTerrainMassOccupancyController | Class that handles and sanity checks the mass logic in the terrain |
| ►CTerrainMaterial | This class is used to describe the general material properties of the Terrain |
| CBulkProperties | Class containing the soil bulk properties of and agxTerrain object |
| CCompactionProperties | Class containing the properties of the soil compaction model used in agxTerrain, such as compression index and soil hardening constants |
| ►CParticleProperties | Class containing the properties of the created soil particles in the Terrain, such as particle density and contact parameters amongst soil particles and between soil particles and the terrain surface |
| CParticleParticleParameters | |
| CParticleTerrainParameters | |
| CTerrainMaterialLibrary | Class that is used for interfacing with different TerrainMaterial presets with calibrated bulk and contact properties of different archetypes of soil, such as dirt, gravel and sand |
| CTerrainMaterialReaderWriter | Utility class for reading and writing TerrainMaterial objects to JSON format |
| ►CTerrainPager | A pager that will dynamically handle terrain tiles in a agxSDK::Simulation |
| CTileAttachments | |
| CTerrainPhysics | Utility class where most of the physics calculation used in agxTerrain is gathered |
| CTerrainProperties | Class for containing and managing the different agxTerrain::Terrain settings |
| CTerrainRasterizer | This class performs raycasting against the source geometry to get height data for tiles |
| CTerrainTile | Struct with data to describe a terrain tile |
| CTileModification | TileModifications are used to provide a delta for paged terrain changes |
| CTileSpecification | A TileSpecification determines where in the world a 2D TileId is located and contains utility methods for coordinate transforms |
| CToolShapeData | |
| CTrajectoryCalculator | |
| CTrajectorySettings | |
| CVoxelGridUtils | |
| ►NagxUnit | |
| CAlwaysFailingAllocator | Never allocates anything, throws always an exception. Only for testing |
| ►CBodyCaptureDeterminism | Class for capturing data for measuring determinism |
| CSession | |
| ►NagxUtil | The agxUtil namespace contain classes and methods for utility functionality |
| CBodyLocalOffset | |
| CBSpline | Https://en.wikipedia.org/wiki/B-spline |
| CCardinalSpline | A Spline constructed of piecewise third-order polynomials which pass through a set of control points |
| CCollectBodiesAndWiresVisitor | This visitor will visit each rigid body and wire in an assembly (or collection) and extract them to a vector with all bodies |
| CConstraintHolder | Utility class to hold custom implementations of constraints |
| CConstraintPosition | Struct that specifies a position for a constraint angle |
| ►CConvexHull2D | Utility class to create a convex hull in a plane given point cloud |
| CPoint | Point in hull containing the point projected onto the plane and the original point |
| CCPCatmullRomBSpline | Https://en.wikipedia.org/wiki/Centripetal_CatmullE2%80%93Rom_spline |
| CCubicSpline | A Spline constructed of piecewise third-order polynomials which pass through a set of control points |
| CExponentialMovingAverageStatistic | Exponential moving average statistic |
| CGeneralContactEventListener | Utility class to get contact event callbacks to any class having the methods implemented |
| CGeneralStepListener | Utility class to get step event callbacks to any class having the methods implemented |
| CHeightFieldGenerator | |
| CHermiteSpline | Https://en.wikipedia.org/wiki/Hermite_spline |
| CJumpRequestWireOption | Jump request options for wire nodes which parent isn't the given assembly/collection |
| CLargerThanPred | Larger than operator to e.g., sort functions |
| CLessThanPred | Less than operator to e.g., sort functions |
| CMedianStatistic | Median statistic that keeps a history of a number of observations and reports the median, i.e., middle element in sorted order, of that |
| CMovingAverageStatistic | Simple moving average statistic |
| CNonUniformCardinalSpline | A Spline constructed of piecewise third-order polynomials which pass through a set of control points |
| COnScopeExit | Register a callback to be called at the end of the current scope |
| CParallelTrimeshDeformer | |
| CParameterizedCatmullRomSpline | Special case of a cardinal spline |
| ►CPointCurve | Utility class curve defined by a set of points |
| CSegment | Segment data with begin and end point |
| CSegmentationResult | Result data of segmentation, PointCurve::findSegmentLength |
| CSegmentPoint | Segment point with current curve segment and a point on that segment with local and global time |
| CPrimitiveMeshGenerator | |
| CRawMesh | A class to hold a general represenation of a mesh with arbitrary number of vertices in a face |
| CReconfigureRequest | This class can be used to compute transforms for a collection of constrained bodies given a set of positions for the constraint angles |
| CSceneRoot | |
| CShapeOrientation | Specify the orientation of cylinder, capsule for computeOrientedCylinder and computeOrientedCapsule |
| CSmoothingFilter | |
| ►CSphereSkeleton | A skeleton with spherical joints |
| Cdfs_iterator | |
| CJoint | A joint in a sphereskeleton |
| CSphereSkeletoniser | A class capable of producing a sphere-skeleton from a trimesh through more granular operations |
| ►CSpline | Base class for splines |
| CPoint | Point class for storing 3D point, tension, stretch and curvature |
| CTangent | Tangent |
| CStatistic | Pure virtual statistic class containing the fundamentals for implementing a statistics method |
| CStatisticHandle | Extra level of indirection provided for use by garbage collected languages |
| CStepEventCallback | Helper to use lambdas as preCollide, pre, post and last step events |
| CSurfaceVelocityContactFilter | This is a utility class that disables ContactPoints where the contact normal prevents movement along the surface velocity direction |
| CTaskGraphWriter | |
| CTextureAtlasGenerator | This class will take an input mesh and recompute texture coordinates to fit on a texture atlas |
| CTimerBlock | Utility class to time a scope |
| CTrimeshDeformer | |
| CTrimeshInterpolator | |
| CUri | |
| CVariableSmoothFactorEMAStatistic | Variable Smooth Factor Exponential Moving Average statistic |
| CVariableSmoothingFactorFilter | Variable Smooth Factor Exponential Moving Average filter |
| ►NagxVehicle | This namespace contains classes related to vehicles dynamics |
| CAckermann | |
| CBellCrank | |
| CDavis | |
| CRackPinion | |
| CSteering | A Steering mechanism is designed to align wheels simultaneously to minimize the slip, making them move along the tangents of concentric circles with radii determined by the distances between the wheels, and the distance between front and rear |
| CSteeringParameters | |
| CTrack | Assembly object representing a continuous track with a given number of shoes (nodes) |
| CTrackDesc | |
| CTrackInternalMergeProperties | Properties and thresholds for internal merging of nodes in agxVehicle::Track |
| CTrackNode | Node/segment/shoe object in agxVehicle::Track |
| CTrackNodeDesc | |
| CTrackNodeOnInitializeCallback | Track node initialize callback, called when a track node has been created and is about to be added to a track |
| CTrackProperties | Object containing properties of an agxVehicle::Track |
| ►CTrackRoute | Track route object to initialize tracks |
| CSegmentationResult | Resulting curve and resolution |
| CWheelInteraction | Wheel <-> node interactions after initialize |
| CTrackWheel | Wheel used in tracked vehicles |
| CTrackWheelDesc | |
| CWheel | Abstraction of a wheel of arbitrary geometry |
| CWheelJoint | The wheel constraint is designed to attach two bodies such that one of them is free to rotate about an axis defined in its own frame, the wheel axle, and about an axis defined in the other body, which would be the chassis |
| CWheelJointConstraintGeometry | Description of constraint geometry for one of the free degrees of freedom of a wheel joint |
| CWheelJointFrame | Helper class to define reference frames for WheelJoint |
| ►NagxWire | Implements a Wire model with adaptive resolution |
| CAreaDefinition | AreaDefinition that specifies an area in which an eye node can move in an EyeNodeArea constraint |
| CBodyFixedNode | The body fixed node is attached to a body at a given offset |
| CCircularAreaDefinition | Class for defining a circular area in which the eye node is allowed to exist |
| ►CConnectingNode | Connecting nodes contains two nodes, one at center of mass and the other at the user defined position |
| CStabilityParameters | Stability parameters object defining the behavior of the constraints associated to this connecting node |
| CContactNode | Contact node class is a node that, currently, is defined to live on an edge on a geometry (agxCollide::Geometry) |
| CContactNodeData | |
| CConvexAreaDefinition | Class for defining a convex area in which the eye node is allowed to exist |
| CCylindricalCoordinateRPY | |
| CEyeNode | Eye node is a type of node that can slide along a wire with or without friction |
| CEyeNodeArea | Constraint that allows an eye node to move in a 2D area relative a rigid body |
| CFreeNode | Free node class used to route wires |
| CHighResolutionRange | Class to control variable node density along wires through routed nodes |
| ►CILinkNode | Interface class for nodes connected to links |
| CConnectionProperties | Object holding parameters, such as bend and twist stiffness, related to wire to link connections |
| CLink | Object that defines the relation between different types of wires (agxWire::Wire) |
| CLinkObjectStabilizingAlgorithm | (Optional) Link algorithm that tries to stabilize the link when the link is in contact with an object |
| CNode | Class defining a node that is part of a wire |
| CNodeFrame | Node coordinate frame in another frame |
| CNodeMaterial | Material definition for a wire node Specifies the friction of a wire for sliding through an EyeNode |
| CRenderIterator | Proxy class for wire iterators |
| CShapeContactNode | |
| CStopNode | Stop node, wire end node used by winches |
| ►CWinch | Winch object which works like agxWire::WireWinchController but enables the features of having stored, inactive, wire segments inside of the winch which can be pulled out given a link |
| CWireLength | Internal data to store the inactive wire and the length of that wire |
| ►CWire | Interface and placeholder of controllers/helpers for wires |
| CTensionData | Structure containing relevant tension data given one look-up |
| CWireController | Overlaying object handling wires |
| CWireNodeForceResult | Resulting force data from wire distance and bend calculateNodeForces calls |
| CWireNodeTensionData | Structure containing relevant tension data for a node |
| ►CWireParameterController | Class to hold specific parameters for the wire - this makes the wires highly configurable |
| CWinchPrismaticCompliance | Structure with compliance parameters for the prismatic constraint used by winches |
| CWireSegmentTensionData | Structure containing relevant tension data for a wire element/segment |
| CWireSimpleDrumController | |
| CWireSimpleDrumControlPoint | |
| CWireTensionController | |
| CWireWinchController | Winch class for handling in and out hauling of wires |
| CGraphicsThrottler | |
1.9.6