Namespace List

Here is a list of all namespaces with brief descriptions:

[detail level 12345]

Neigen3
▼Ngz	This library is part of the Gazebo project
Ncommon
Ngui
Nmath
Nmsgs
Nplugin
Nsensors
►Nsim	Gazebo is a leading open source robotics simulator, that provides high fidelity physics, rendering, and sensor simulation
►Ncomms
CAddressContent	All the information associated to an address
CBroker	A class to store messages to be delivered using a comms model. This class should be used in combination with a specific comms model that implements the ICommsModel interface
CICommsModel	Abstract interface to define how the environment should handle communication simulation. As an example, this class could be responsible for handling dropouts, decay and packet collisions
CMsgManager	Class to handle messages and subscriptions
►Ncomponents	Components represent data, such as position information. An Entity usually has one or more associated components
CBaseComponent	Base class for all components
CBatteryPowerLoadInfo	Data structure to hold the consumer power load and the name of the battery it uses
CComponent	A component type that wraps any data type. The intention is for this class to be used to create simple components while avoiding a lot of boilerplate code. The Identifier must be a unique type so that type aliases can be used to create new components. However the type does not need to be defined anywhere eg
CComponent< NoData, Identifier, Serializer >	Specialization for components that don't wrap any data. This class to be used to create simple components that represent just a "tag", while avoiding a lot of boilerplate code. The Identifier must be a unique type so that type aliases can be used to create new components. However the type does not need to be defined anywhere eg
CComponentDescriptor	A class for an object responsible for creating components
CComponentDescriptorBase	A base class for an object responsible for creating components
CComponentDescriptorQueue	A class to hold the queue of component descriptors registered by translation units. This queue is necessary to ensure that component creation continues to work after plugins are unloaded. The typical scenario this aims to solve is:
CDetachableJointInfo	Data structure to hold information about the parent and child links connected by a detachable joint
CEnvironmentalData	Environment data across time and space. This is useful to introduce physical quantities that may be of interest even if not modelled in simulation
CFactory	A factory that generates a component based on a string type
CRaycastDataInfo	A struct that holds the raycasting data, including ray and results
CRaycastResultInfo	A struct that holds the result of a raycasting operation
CRayInfo	A struct that holds the information of a ray
CRegistrationObjectId	A wrapper around uintptr_t to prevent implicit conversions
CTemperatureRangeInfo	Data structure to hold a temperature range, in kelvin
Nevents	Namespace for all events. Refer to the EventManager class for more information about events
►Ngui
►Nevents	Namespace for all events. Refer to the EventManager class for more information about events
CDeselectAllEntities	Event that notifies when all entities have been deselected
CEntitiesSelected	Event that notifies when new entities have been selected
CGuiNewRemovedEntities	Event that contains entities newly created or removed from the GUI, but that aren't present on the server yet
CModelEditorAddEntity	Event that notifies an entity is to be added to the model editor
CNewRemovedEntities	Event that notifies when new entities have been created or removed on the server. This is a duplication of what GuiSystems would get from EachNew / EachRemoved ECM calls
CTransformControlModeActive	True if a transform control is currently active (translate / rotate / scale). False if we're in selection mode
CVisualPlugins	Event that notifies a visual plugin is to be loaded
CPlot3D	Plot the trajectory of an entity into the 3D scene
CSelectEntities	This plugin is in charge of selecting and deselecting the entities from the 3D scene and emit the corresponding events
►NGZ_SIM_VERSION_NAMESPACE
CEnvironmentLoader	A GUI plugin for a user to load an Environment component into the ECM on a live simulation
CEnvironmentVisualization	A GUI plugin for a user to load an Environment component into the ECM on a live simulation
CEnvironmentVisualizationTool	This class helps handle point cloud visuallizations of environment data
CGlobalIlluminationCiVct	Enable and configure Global Illumination using CIVCT (Cascaded Image Voxel Cone Tracing)
CGlobalIlluminationVct	Enable and configure Global Illumination using VCT (Voxel Cone Tracing)
CVisualizeContacts	Visualize the contacts returned by the Physics plugin. Use the checkbox to turn visualization on or off and spin boxes to change the size of the markers
►CVisualizeFrustum	Visualize the frustum from supported camera sensor messages
CFrustumData	Frustum parameters extracted from a supported sensor message
CVisualizeLidar	Visualize the LaserScan message returned by the sensors. Use the checkbox to turn visualization of non-hitting rays on or off and the textfield to select the message to be visualised. The combobox is used to select the type of visual for the sensor data
►Ninspector
CInertial	A class that handles Inertial components
CPose3d	Handles components that are displayed as a 3D pose:
CSystemPluginInfo	A class that handles SystemPluginInfo components
►Nlogical_audio
CMicrophone	Properties of a logical audio microphone. A microphone also has a pose, which can be stored as a component of a microphone entity via components::Pose
CSource	Properties of a logical audio source. A source also has a pose, which can be stored as a component of a source entity via components::Pose
CSourcePlayInfo	A source's playing information. Useful for keeping track of when to start/stop playing a source
►Nserializers	A Serializer class is used to serialize and deserialize a component. It is passed in as the third template parameter to components::Component. Eg
CAnimationTimeSerializer
CComponentToMsgSerializer	Serialization for that converts components data types to gz::msgs. This assumes that convert<DataType> is defined
CDefaultSerializer	Default serializer template to call stream operators only on types that support them. If the stream operator is not available, a warning message is printed
CDefaultSerializer< components::NoData >	Specialization of DefaultSerializer for NoData
CDefaultSerializer< components::RaycastDataInfo >	Specialization of DefaultSerializer for RaycastDataInfo
CDefaultSerializer< sdf::World >	Specialize the DefaultSerializer on sdf::World so we can skip serialization TODO(azeey) Do we ever want to serialize this component?
CDetachableJointInfoSerializer	Serializer for DetachableJointInfo object
CJointTypeSerializer
CLevelEntityNamesSerializer
CLogicalAudioSourcePlayInfoSerializer	Serializer for components::LogicalAudioSourcePlayInfo object
CLogicalAudioSourceSerializer	Serializer for components::LogicalAudioSource object
CLogicalMicrophoneSerializer	Serializer for components::LogicalMicrophone object
CMsgSerializer	Serializer for components that hold protobuf messages
CPerformerLevelsSerializer
CSdfElementSerializer
CSdfModelSerializer
CSemanticDescriptionSerializer
CSemanticTagsSerializer
CStringSerializer	Serializer for components that hold std::string
CTemperatureRangeInfoSerializer	Serializer for components::TemperatureRangeInfo object
CVectorDoubleSerializer	Serializer for components that hold std::vector<double>
CVectorSerializer
►Nsystems	Namespace for all System plugins. Refer to the System class for more information about systems
►Nactions
CCabinAtTarget	Action that cleans up the target queue when the cabin reaches the target floor level
CEnqueueNewTarget	Action that enqueues a new target in the target queue
CNewTarget	Action that cleans up the target queue when a new target is processed
►Nevents
CCabinAtTarget	Event that signifies the cabin has reached the target floor level
CDoorClosed	Event that signifies the door at the target floor level has been closed
CDoorOpen	Event that signifies the door at the target floor level has been opened
CEnqueueNewTarget	Event that signifies there is a new target that needs to be enqueued
CNewTarget	Event that signifies a new target will be processed
CTimeout	Event that signifies the door at the target floor level has remained open for the required amount of time
►Nguards
CCabinAtTarget	Guard that checks whether the cabin is at the target floor level
CIsInState	Guard that checks whether the state machine is in a given state
CNoQueuedTarget	Guard that checks whether the target queue is empty
►Nmulticopter_control
CEigenTwist	Struct containing linear and angular velocities
CFrameData	Frame data of a link including its pose and linear velocity in world frame as well as its angular velocity in body frame
CLeeVelocityController
CLeeVelocityControllerParameters	Data structure containing various parameters for the Lee velocity controller
CNoiseParameters	Noise parameters used when computing frame data. These are all assumed to be gaussian
CRotor	A struct that holds various properties of a rotor
CVehicleParameters	A struct that holds properties of the vehicle such as mass, inertia and rotor configuration. Gravity is also included even though it's not a parameter unique to the vehicle
►Noptical_tactile_sensor
COpticalTactilePluginVisualization
►Nphysics_system
CCanonicalLinkModelTracker	Helper class that keeps track of which models have a particular canonical link. This is useful in the physics system for updating model poses - if a canonical link moved in the most recent physics step, then all of the models that have this canonical link should be updated. It's important to preserve topological ordering of the models in case there's a nested model that shares the same canonical link (in a case like this, the parent model pose needs to be updated before updating the child model pose - see the documentation that explains how model pose updates are calculated in PhysicsPrivate::UpdateSim to understand why nested model poses need to be updated in topological order)
CEntityFeatureMap
CAckermannSteering	Ackermann steering controller which can be attached to a model with any number of left and right wheels
CAcousticComms	A comms model that simulates communication using acoustic devices. The model uses simple distance based acoustics model
CAdvancedLiftDrag	The LiftDrag system computes lift and drag forces enabling simulation of aerodynamic robots
CAirPressure	An air pressure sensor that reports vertical position and velocity readings over gz transport
CAirSpeed	An air speed sensor that reports vertical position and velocity readings over gz transport
CAltimeter	An altimeter sensor that reports vertical position and velocity readings over gz transport
CApplyJointForce	This system applies a force to the first axis of a specified joint
CApplyLinkWrench	Exposes transport topics and SDF params for applying forces and torques to links in simulation. It should be attached to a world
CBreadcrumbs	A system for creating Breadcrumbs in the form of models that can get deployed/spawned at the location of the model to which this system is attached. Each breadcrumb is a complete sdf::Model. When deployed, the pose of the breadcrumb model is offset from the containing model by the pose specified in the <pose> element of the breadcrumb model. A name is generated for the breadcrumb by appending the current count of deployments to the name specified in the breadcrumb <model> element. The model specified in the <breadcrumb> parameter serves as a template for deploying multiple breadcrumbs of the same type. Including models from Fuel is accomplished by creating a <model> that includes the Fuel model using the <include> tag. See the example in examples/worlds/breadcrumbs.sdf
CBuoyancy	A system that simulates buoyancy of objects immersed in fluid. All SDF parameters are optional. This system must be attached to the world and this system will apply buoyancy to all links that have collision shapes
CBuoyancyEnginePlugin	This class provides a simple mechanical bladder which is used to control the buoyancy of an underwater glider. It uses Archimedes' principle to apply an upward force based on the volume of the bladder. It listens to the topic buoyancy_engine or /model/{namespace}/buoyancy_engine topic for the volume of the bladder in cubicmeters
CCameraVideoRecorder	Record video from a camera sensor
CColladaWorldExporter	A plugin that exports a world to a mesh. When loaded the plugin will dump a mesh containing all the models in the world to the current directory
CCommsEndpoint	A system that registers in the comms broker an endpoint. You're creating an address attached to the model where the plugin is running. The system will bind this address in the broker automatically for you and unbind it when the model is destroyed
CContact	Contact sensor system which manages all contact sensors in simulation
CDetachableJoint	A system that initially attaches two models via a fixed joint and allows for the models to get detached during simulation via a topic. A model can be re-attached during simulation via a topic. The status of the detached state can be monitored via a topic as well
CDiffDrive	Differential drive controller which can be attached to a model with any number of left and right wheels
CDoorTimer	Timer that's used to keep a door open. It has a configurable default wait duration that when exceeded, it calls a function to let the state machine know to transition to the next state. The timer also checks whether the doorway is blocked, in which case it keeps the door open until whatever blocks the doorway moves out of the way
CDopplerVelocityLogSystem	System that creates and updates DopplerVelocityLog (DVL) sensors
CElevator	System that controls an elevator. It closely models the structure and functionality of a real elevator. It individually controls the cabin and doors of the elevator, queues commands for the elevator and stops at intermediate floors if a command is received while the last one is ongoing, and keeps a door open if the doorway is blocked. The model of the elevator can have arbitrarily many floor levels and at arbitrary heights each
►CElevatorStateMachineDef	Elevator state machine frontend. Defines the transition table and initial state of the state machine
CCloseDoorState	State at which the elevator is closing a door
CIdleState	State at which the elevator is idling
CMoveCabinState	State at which the elevator is moving the cabin to the target floor
COpenDoorState	State at which the elevator is opening a door
CWaitState	State at which the elevator is waiting with a door open
CElevatorStateMachinePrivate
CEntitySemantics	System for assigning semantics to entities, such as models, by classifying them into categories and assigning them tags. Reference: https://github.com/ros-simulation/simulation_interfaces/blob/main/msg/EntityInfo.msg, https://github.com/ros-simulation/simulation_interfaces/blob/main/msg/EntityCategory.msg, https://github.com/ros-simulation/simulation_interfaces/blob/main/msg/TagsFilter.msg
CEnvironmentPreload	A plugin to preload an Environment component into the ECM upon simulation start-up
CFollowActor	Make an actor follow a target entity in the world
CForceTorque	This system manages all Force-Torque sensors in simulation. Each FT sensor reports readings over Gazebo Transport
CHydrodynamics	This class provides hydrodynamic behaviour for underwater vehicles It is shamelessly based off Brian Bingham's plugin for VRX. which in turn is based of Fossen's equations described in "Guidance and Control of Ocean Vehicles" [1]. The class should be used together with the buoyancy plugin to help simulate behaviour of maritime vehicles. Hydrodynamics refers to the behaviour of bodies in water. It includes forces like linear and quadratic drag, buoyancy (not provided by this plugin), etc
CImu	This system manages all IMU sensors in simulation. Each IMU sensor eports vertical position, angular velocity and lienar acceleration readings over Gazebo Transport
CJointController	Joint controller which can be attached to a model with a reference to a single joint. Currently only the first axis of a joint is actuated
CJointMonitor	Monitor that checks the state of a joint. When the joint reaches the configured target, it calls a function to let the state machine know to transition to the next state
CJointPositionController	Joint position controller which can be attached to a model with a reference to a single joint
CJointStatePublisher	The JointStatePublisher system publishes joint state information for a model. The published message type is gz::msgs::Model, and the publication topic is determined by the <topic> parameter
CJointTrajectoryController	Joint trajectory controller, which can be attached to a model with reference to one or more 1-axis joints in order to follow a trajectory
CKineticEnergyMonitor	A system that monitors the kinetic energy of a link in a model and publishes when there is a lost of kinetic energy during a timestep that surpasses a specific threshold. This system can be used to detect when a model could be damaged
CLabel	A label plugin that annotates models by setting the label for the parent entity's visuals. The plugin can be attached to models, visuals, or actors
CLensFlare	Add lens flare effects to the camera output as a render pass
CLiftDrag	The LiftDrag system computes lift and drag forces enabling simulation of aerodynamic robots
CLighterThanAirDynamics	This class provides the effect of viscousity on the hull of lighter-than-air vehicles such as airships. The equations implemented is based on the work published in [1], which describes a modeling approach for the nonlinear dynamics simulation of airships and [2] providing more insight of the modelling of an airship
CLinearBatteryPlugin	A plugin for simulating battery usage
CLogicalAudioSensorPlugin	A plugin for logical audio detection
CLogicalCamera	A logical camera sensor that reports objects detected within its frustum readings over gz transport
CLogPlayback	Log state playback
CLogRecord	Log state recorder
CLogVideoRecorder	System which recordings videos from log playback There are two ways to specify what entities in the log playback to follow and record videos for: 1) by entity name and 2) by region. See the system parameters
CMagnetometer	An magnetometer sensor that reports the magnetic field in its current location
CMecanumDrive	Mecanum drive controller which can be attached to a model with any number of front/back left/right wheels
CModelPhotoShoot	This plugin is a port of the old ModelPropShop plugin from gazebo classic. It generates 5 pictures of a model: perspective, top, front, side and back. It can do it using the default position or moving the joint to random positions. It allows saving the camera and joint poses so it can be replicated in other systems
CMulticopterMotorModel	This system applies a thrust force to models with spinning propellers. See examples/worlds/quadcopter.sdf for a demonstration
CMulticopterVelocityControl	This is a velocity controller for multicopters that allows control over the linear velocity and the yaw angular velocity of the vehicle. The velocities are expressed in the body frame of the vehicle. A vehicle with at least 4 rotors is required for the controller to function
CNavSat	System that handles navigation satellite sensors, such as GPS, that reports position and velocity in spherical coordinates (latitude / longitude) over Gazebo Transport
COdometryPublisher	Odometry Publisher which can be attached to any entity in order to periodically publish 2D or 3D odometry data in the form of gz::msgs::Odometry messages
COpticalTactilePlugin	Plugin that implements an optical tactile sensor
CParticleEmitter	A system for running and managing particle emitters. A particle emitter is defined using the <particle_emitter> SDF element
CPerfectComms	An example of a comms model. This model always delivers any message to its destination
CPerformerDetector	A system system that publishes on a topic when a performer enters or leaves a specified region
CPhysics	Base class for a System
CPosePublisher	Pose publisher system. Attach to an entity to publish the transform of its child entities in the form of gz::msgs::Pose messages, or a single gz::msgs::Pose_V message if "use_pose_vector_msg" is true
CPythonSystemLoader	Allows systems to be written in Python
CRFComms	A comms model that simulates communication using radio frequency (RF) devices. The model uses a log-distance path loss function
CSceneBroadcaster	System which periodically publishes a gz::msgs::Scene message with updated information
CSensors	A system that manages sensors
CShaderParam	A plugin for setting shaders to a visual and its params
CSpacecraftThrusterModel	This system applies a thrust force to models with RCS-like thrusters. See tutorials/spacecraft_thrusters.md for a tutorial usage. Below follow the minimum necessary parameters needed by the plugin:
CThermal	A thermal plugin that sets the temperature for the parent entity
CThermalSensor	A thermal sensor plugin for configuring thermal sensor properties
CThruster	This plugin simulates a maritime thruster for boats and underwater vehicles. It uses the equations described in Fossen's "Guidance and Control of Ocean Vehicles" in page 246. This plugin has two modes of operation. In the default mode it takes in a force in Newtons and applies it to the thruster. It also calculates the theoretical angular velocity of the blades and spins them accordingly. Alternatively, one may send angular velocity commands to calculate the force to be applied using the said equation. In the default mode the plugin will publish angular velocity in radians per second on /model/{ns}/joint/{joint_name}/ang_vel as a gz.msgs.double. If <use_angvel_cmd> is set to true it publishes force in Newtons instead to /model/{ns}/joint/{joint_name}/force
CTouchPlugin	Plugin which publishes a message if the model it is attached to has touched one or more specified targets continuously during a given time
CTrackController	Controller of a track on either a conveyor belt or a tracked vehicle. The system should be attached to a model. If implementing a tracked vehicle, use also TrackedVehicle system
CTrackedVehicle	Tracked vehicle controller which can be attached to a model with any number of left and right tracks. The system should be attached to a model. Each track has to have a TrackController system configured and running
CTrajectoryFollower	A plugin that scripts the movement of a model based on waypoints. Note that at this point, the trajectory is always in 2D (x, y). The plugin applies a torque until the model is aligned with the next waypoint. Then, it applies a force until the model is close enough to the waypoint
CTriggeredPublisher	The triggered publisher system publishes a user specified message on an output topic in response to an input message that matches user specified criteria. It can also call a user specified service as an output in response to an input message. It currently supports blocking service call. An optional simulation time delay can be used delay message publication
CUserCommands	This system provides a Gazebo Transport interface to execute commands while simulation is running
CVelocityControl	Linear and angular velocity controller which is directly set on a model
CWheelSlip	A system that updates wheel slip parameters based on linear wheel spin velocity (radius * spin rate)
CWindEffects	A system that simulates a simple wind model. The wind is described as a uniform worldwide model. Its components are computed separately:
►Ntraits
CHasGazeboConvert	Type trait that determines if a convert from In to Out is defined. Usage:
CIsInStreamable	Type trait that determines if a operator>> is defined on Stream and DataType, i.e, it checks if the function Stream& operator>>(Stream&, DataType&) exists. Example:
CIsInStreamable< std::istream, sdf::World >
CIsOutStreamable	Type trait that determines if a operator<< is defined on Stream and DataType, i.e, it checks if the function Stream& operator<<(Stream&, const DataType&) exists. Example:
CIsOutStreamable< std::ostream, sdf::World >
CIsSharedPtr	Helper trait to determine if a type is shared_ptr or not
CIsSharedPtr< std::shared_ptr< T > >	Helper trait to determine if a type is shared_ptr or not
CActor	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a actor entity
CAirPressure	A class that handles air pressure changes
CAlignTool	Provides buttons for the align tool
CAltimeter	A class that handles altimeter changes
CAnimationUpdateData	Data structure for updating skeleton animations
CApplyForceTorque	Publish wrench to "/world/<world_name>/wrench" topic. Automatically loads the ApplyLinkWrench system
CBananaForScale	Provides buttons for adding a banana for scale
CCopyPaste	Plugin for copying/pasting entities in the GUI
CDisplay	Data used by the DisplayData() function to filter and sort the resources to be displayed
CEntityComponentManager	The EntityComponentManager constructs, deletes, and returns components and entities. A component can be of any class which inherits from components::BaseComponent
CEntityContextMenu	This plugin is in charge of showing the entity context menu when the right button is clicked on a visual
CEntityContextMenuHandler
CEntityContextMenuItem	A QQUickItem that manages the render window
CEntityTree	Displays a tree view with all the entities in the world
CEnvironmentalSensorSystem	Sensor for reading environmental data loaded from outside world. To use, add this system to the world file, then instantiate sensors of custom type with gz:type="environmental_sensor/{field_name}", where field_name refers to the type of data you would like to output. Alternatively, if you would like to specify a custom field name you may do so using the <environment_variable> tag
CEnvironmentLoader	A GUI plugin for a user to load an Environment component into the ECM on a live simulation
CEnvironmentVisualization	A GUI plugin for a user to load an Environment component into the ECM on a live simulation
CEnvironmentVisualizationTool	This class helps handle point cloud visuallizations of environment data
CEventManager	The EventManager is used to send/receive notifications of simulator events
CGlobalIlluminationCiVct	Enable and configure Global Illumination using CIVCT (Cascaded Image Voxel Cone Tracing)
CGlobalIlluminationVct	Enable and configure Global Illumination using VCT (Voxel Cone Tracing)
CGuiSystem	Base class for a GUI System
CGzSceneManager	Updates a 3D scene based on information coming from the ECM. This plugin doesn't instantiate a new 3D scene. Instead, it relies on another plugin being loaded alongside it that will create and paint the scene to the window, such as gz::gui::plugins::MinimalScene
CGzSimPlugin	GzSim QML Plugin that registers C++ class so that they are accessible from QML
CImu	A class that handles IMU sensor changes
CISystemConfigure	Interface for a system that implements optional configuration
CISystemConfigureParameters	Interface for a system that declares parameters
CISystemConfigurePriority
CISystemPostUpdate	Interface for a system that uses the PostUpdate phase
CISystemPreUpdate	Interface for a system that uses the PreUpdate phase
CISystemReset
CISystemUpdate	Interface for a system that uses the Update phase
CJoint	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a joint entity
CJointType	A class that handles joint changes
CLidar	A class that handles Lidar sensor changes
CLight	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a light entity
CLights	Provides buttons for adding a point, directional, or spot light to the scene
CLink	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a link entity
CMagnetometer	A class that handles magnetometer changes
CMarkerManager	Creates, deletes, and maintains marker visuals. Only the Scene class should instantiate and use this class
CModel	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a model entity
CModelEditor	Model Editor
CMouseDrag	Translate and rotate links by dragging them with the mouse. Automatically loads the ApplyLinkWrench system
CPathModel	Provides a model by which the resource spawner qml plugin pulls and updates from
CPlaybackScrubber	Provides slider and functionality for log playback. to the scene
CPlotComponent	A container of the component data that keeps track of the registered attributes and update their values and their registered charts
CPlotting	Physics data plotting handler that keeps track of the registered components, update them and update the plot
CPose3d	A class that handles Pose3d changes
CRenderUtil
CResource	Resource used to update the ResourceModel
CResourceModel	Provides a model by which the resource spawner qml plugin pulls and updates from
CResourceSpawner	Provides interface for communicating to backend for generation of local models
CSceneManager	Scene manager class for loading and managing objects in the scene
CSdfEntityCreator	Provides convenient functions to spawn entities and load their plugins from SDF elements, to remove them, and to change their hierarchy
CSensor	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a sensor entity
CServer	The server instantiates and controls simulation
►CServerConfig	Configuration parameters for a Server. An instance of this object can be used to construct a Server with a particular configuration
CPluginInfo	Information about a plugin that should be loaded by the server
CShapes	Provides buttons for adding a box, sphere, or cylinder to the scene
CSpawn	Allows to spawn models and lights using the spawn gui events or drag and drop
CSystem	Base class for a System
CSystemLoader	Class for loading/unloading System plugins
CTestFixture	Helper class to write automated tests. It provides a convenient API to load a world file, step simulation and check entities and components
CTransformControl	Provides buttons for translation, rotation, and scale
CTreeModel	TODO
CUpdateInfo	Information passed to systems on the update callback
CVideoRecorder	Provides video recording cababilities to the 3D scene
CViewAngle	Provides buttons for viewing angles
CVisualizationCapabilities	Allows to visualize transparent, collisions, inertial, CoM and more
CVisualizeContacts	Visualize the contacts returned by the Physics plugin. Use the checkbox to turn visualization on or off and spin boxes to change the size of the markers
►CVisualizeFrustum	Visualize the frustum from supported camera sensor messages
CFrustumData	Frustum parameters extracted from a supported sensor message
CVisualizeLidar	Visualize the LaserScan message returned by the sensors. Use the checkbox to turn visualization of non-hitting rays on or off and the textfield to select the message to be visualised. The combobox is used to select the type of visual for the sensor data
CWorld	This class provides wrappers around entities and components which are more convenient and straight-forward to use than dealing with the EntityComponentManager directly. All the functions provided here are meant to be used with a world entity
Ntransport
Nlog
Nparameters
Nstd	STL namespace
Ntesting