Menge
Modular Pedestrian Simulation Framework for Research and Development
|
►NMenge | The core namespace. All elements of Menge are contained in this namespace |
►NAgents | |
CAgentException | Exception for BaseAgent problems |
CAgentFatalException | The fatal agent exception |
CAgentGenerator | The base class inital agent generation |
CAgentGeneratorException | Exception class for agent generator computation |
CAgentGeneratorFactory | A class for parsing the xml description of an agent generator and instantiating particular instances |
CAgentGeneratorFatalException | The fatal agent generator exception |
CAgentImplementationException | Special agent exception - used for non-implemented functionality |
CAgentInitializer | Class which determines the agent properties for each new agent |
CAgentKDTree | A kd-tree for performing nearest-neighbor searches |
CBaseAgent | Defines the basic agent properties and functionality that all simulation agents share |
CBergKDTree | Spatial query object. Used to determine obstacles and agents near an agent – based on a kd-tree |
CBergKDTreeFactory | Factory for the BergKDTree |
CConstProfileSelector | A profile selector that stores a single agent initializer and assigns this profile to all agents |
CConstProfileSelectorFactory | The factory for the ConstProfileSelector |
CConstStateSelector | An initial state selector that stores a single state and assigns that state to all agents |
CConstStateSelectorFactory | The factory for the ConstStateSelector |
CElevation | The base class for determining an agent's elevation |
CElevationException | Exception class for elevation computation |
CElevationFactory | A class for parsing the xml description of an action and instantiating particular instances |
CElevationFatalException | The fatal elevation exception |
CExplicitGenerator | Definition of agent generator class which produces agents based on explicit enumeration of agent positions in an XML file |
CExplicitGeneratorFactory | Factory for ExplicitGenerator |
CExplicitObstacleSet | Definition of obstacle set class which produces obstacles based on explicit definition in an XML file |
CExplicitObstacleSetFactory | Factory for ExplicitGenerator |
CFlatElevation | Defintion of elevation class representing flat ground |
CFlatElevationFactory | Factory for the FlatElevation |
CHexLatticeGenerator | Definition of an agent generator class which produces agents based on the positions of intersections on a hexagonal lattice bounded by a rectangle |
CHexLatticeGeneratorFactory | Factory for HexLatticeGenerator |
CKNearestQuery | The K-Nearest query class |
CListObstacleSet | Definition of obstacle set class which produces obstacles based on explicit definition in an XML file |
CNavMeshElevation | Elevation definition based on a navigation mesh |
CNavMeshElevationFactory | Factory for the NavMeshElevation |
CNavMeshObstacleSet | Definition of obstacle set class which produces obstacles based on explicit definition in an XML file |
CNavMeshObstacleSetFactory | Factory for NavMeshObstacleSet |
CNavMeshSpatialQuery | A spatial query structure based on a navigation mesh |
CNavMeshSpatialQueryFactory | Factory for the NavMeshSpatialQuery |
CNearAgent | Struct to store agent proximity query results |
CNearObstacle | Struct to store obstacle proximity query results |
CNeighborEntry | An entry of a nav mesh node including the distance to the node. Used in the queue to search nearby nodes |
CObstacle | Defines static obstacles in the simulation |
CObstacleKDTree | Defines an obstacle kd-tree |
CObstacleSet | The base class for obstacle set definitions |
CObstacleSetException | Exception class for obstacle set instantiation |
CObstacleSetFactory | A class for parsing the xml description of an agent generator and instantiating particular instances |
CObstacleSetFatalException | The fatal obstacle set exception |
CObstacleTreeNode | Defines an obstacle kd-tree node |
CObstacleVertexList | A strcuture for passing vertices and closed tags for obstacles |
CPrefVelocity | The definition of a preferred velocity |
CProfileSelector | The base class for agent profile assignment strategies |
CProfileSelectorException | Exception class for profile selector computation |
CProfileSelectorFactory | A class for parsing the xml description of an agent profile selector elements and instantiating particular instances |
CProfileSelectorFatalException | The fatal profile selector exception |
CProximityQuery | The base class for filtering spatial queries according to proximity |
CRectGridGenerator | Definition of an agent generator class which produces agents based on the positions of intersections on a lattice–one agent per intersection |
CRectGridGeneratorFactory | Factory for RectGridGenerator |
CSCBException | Base exception class for scb writers |
CSCBFatalException | The fatal scb writers exception |
CSCBFileException | Exception raised for file I/O errors |
CSCBFrameWriter | This base class for writing a single frame of simulation data to the scb file |
CSCBFrameWriter1_0 | Writer for version 1.0 |
CSCBFrameWriter2_0 | Writer for version 2.0 |
CSCBFrameWriter2_1 | Writer for version 2.1 |
CSCBFrameWriter2_2 | Writer for version 2.2 |
CSCBFrameWriter2_3 | Writer for version 2.3 |
CSCBFrameWriter2_4 | Writer for version 2.4 |
CSCBVersionException | Exception raised for invalid scb version |
CSCBWriter | Class responsible for writing the agent state of the simulator and fsm into a file |
CSimulatorBase | Defines the basic simulator. It is responsible for tracking agents and obstacles as well as initializing such from files |
CSimulatorInterface | The basic simulator interface required by the fsm |
CSimulatorState | A class which caches the state of the simulator |
CSimXMLLoader | Class for parsing the SCENE XML specification and initialize a simulator It only knows the most fundamental common aspects of the file, relying on the Simulator to know of its own specific domain knowledge |
CSpatialQuery | The base class for performing spatial queries |
CSpatialQueryException | Exception class for spatial query operations |
CSpatialQueryFactory | A class for parsing the xml description of a spatial query and instantiating particular instances |
CSpatialQueryFatalException | The fatal spatial query exception |
CStateSelector | The base class for selecting an agent's intial state |
CStateSelectorException | Exception class for state selector computation |
CStateSelectorFactory | A class for parsing the xml description of an initial state selector element and instantiating particular instances |
CStateSelectorFatalException | The fatal state selector exception |
CVisibilityCone | A visiblity cone. In order for an agent to be visible, they must lie within the visibility cone |
CXMLParamException | Exception for invalid parameters from XML specification |
CXMLParamFatalException | Exception thrown when the xml parameter parser has an error which cannot be recovered from |
CXMLSimulatorBase | The base class for extracting simulator settings from the XML specification |
►NBFSM | |
CAABBCondFactory | The factory for creating the AABBCondition |
CAABBCondition | A transition based on spatial relationship with an axis-aligned bounding box (AABB) |
CAABBGoal | A axis-aligned bounding box goal region with uniform probability |
CAABBGoalFactory | Factory for the AABBGoal |
CAction | The abstract definition of an action |
CActionFactory | A class for parsing the xml description of an action and instantiating particular instances |
CAddObstacleSetAction | Modifies the agent's obstacle set by ADDING the given obstacle set value |
CAddObstacleyActFactory | Factory for the ObstacleActFactory |
CAndCondFactory | The factory for creating the AndCondition |
CAndCondition | A condition based on the boolean and of two conditions |
CAutoCondFactory | The factory for creating the AutoCondition |
CAutoCondition | The definition of the "auto" condition |
CBool2CondFactory | The factory for creating the Bool2Condition |
CBool2Condition | The base class for binary boolean operand as a transition condition |
CCircleCondFactory | The factory for creating the SpaceCondition |
CCircleCondition | A transition based on spatial relationship with a circle |
CCircleGoal | A circular goal region with uniform probability |
CCircleGoalFactory | Factory for the CircleGoal |
CCondition | The base class for transition conditions |
CConditionFactory | The class for parsing the xml description of a Condition and instantiating particular instances |
CConstDirVCContext | The context for the ConstVelDirComponent |
CConstDirVCFactory | Factory for the ConstVelDirComponent |
CConstVCContext | The context for the ConstVelComponent |
CConstVCFactory | Factory for the ConstVelComponent |
CConstVelComponent | A velocity component that always returns a constant velocity |
CConstVelDirComponent | A velocity component that always returns a constant direction but leaves the preferred speed unchanged |
CExplicitGoalSelector | The explicit goal selector makes extracts a specific goal from a specific goal set – both explicitly stated |
CExplicitGoalSelectorFactory | Factory for the ExplicitGoalSelector |
CFarthestGoalSelector | The nearest goal selector selects the goal from a goal set that is farthest to the agent in terms of Euclidian distance |
CFarthestGoalSelectorFactory | Factory for the FarthestGoalSelector |
CFarthestNMGoalSelector | The farthest nav mesh goal selector selects the goal from a goal set that is farthest to the agent in terms of path length through the navigation mesh |
CFarthestNMGoalSelectorFactory | Factory for the FarthestNMGoalSelector |
CFSM | Templated class for the behavior finite state machine |
CFsmContext | Base context for finite state machine elements |
CFSMDescrip | The full description of the behavioral finite state machine |
CFSMException | Generic base class for FSM exceptions |
CFSMFatalException | Exception thrown when the FSM has an error which cannot be recovered from |
CGoal | The base, abstract class defining goals |
CGoalCondFactory | The factory for creating the GoalCondition |
CGoalCondition | A spatial transition based on individual goal positions |
CGoalException | Exception class for BFSM goals |
CGoalFactory | A class for parsing the xml description of a goal and instantiating particular instances |
CGoalFatalException | Exception thrown when the goal has an error which cannot be recovered from |
CGoalSelector | The base, abstract class for selecting per-agent goals |
CGoalSelectorException | Exception class for goal generation |
CGoalSelectorFactory | A class for parsing the xml description of a goal selector and instantiating particular instances |
CGoalSelectorFatalException | Exception thrown when the goal selector has an error which cannot be recovered from |
CGoalSet | A set of goals. Maps integer identifiers to instances of goals |
CGoalVCContext | The context for the GoalVelComponent |
CGoalVCFactory | Factory for the GoalVelComponent |
CGoalVelComponent | A velocity component that returns a preferred velocity whose direction points from the current agent position toward the goal point |
CIdentityGoalSelector | The identity goal selector makes a goal out of the agent's current position when assigned. The goal is not associated with any set and should be destroyed upon being freed |
CIdentityGoalSelectorFactory | Factory for the IdentityGoalSelector |
CMirrorGoalSelector | The mirror goal selector makes a goal by reflecting the agent's position around the world's origin. The reflection across the x- and y-axes can be individually specified |
CMirrorGoalSelectorFactory | Factory for the MirrorGoalSelector |
CNavMeshLocalizerTask | Sub-class of NavMeshLocalizer that can be run as an FSM task |
CNavMeshVCContext | The context for the NavMeshVelComponent |
CNavMeshVCFactory | Factory for the NavMeshVelComponent |
CNavMeshVelComponent | A velocity component that returns a preferred velocity whose direction and preferred speed are computed from a navigation mesh |
CNearestGoalSelector | The nearest goal selector selects the goal from a goal set that is nearest to the agent in terms of Euclidian distance |
CNearestGoalSelectorFactory | Factory for the NearestGoalSelector |
CNearestNMGoalSelector | The nearest nav mesh goal selector selects the goal from a goal set that is nearest to the agent in terms of path length through the navigation mesh |
CNearestNMGoalSelectorFactory | Factory for the NearestNMGoalSelector |
CNotCondFactory | The factory for creating the NotCondition |
CNotCondition | A condition based on the boolean negation of a single condition |
COBBCondFactory | The factory for creating the OBBCondition |
COBBCondition | A transition based on spatial relationship with an axis-aligned bounding box (AABB) |
COBBGoal | An oriented bounding box goal region with uniform probability |
COBBGoalFactory | Factory for the OBBGoal |
CObstacleActFactory | Factory for the ObstacleAction |
CObstacleAction | The base class for modifying agent obstacle sets |
COffsetGoalSelector | The offset goal selector makes a goal by applying an offset value to the agent's position at assignment time. The offsets can be defined with a distribution |
COffsetGoalSelectorFactory | Factory for the OffsetGoalSelector |
COffsetPropertyActFactory | Factory for the OffsetPropertyAction |
COrCondFactory | The factory for creating the OrCondition |
COrCondition | A condition based on the boolean OR of two conditions |
CPointGoal | A simple point goal. The goal is trivially this point |
CPointGoalFactory | Factory for the PointGoal |
CProbTarget | The definition of the probabalistic target |
CProbTargetFactory | The factory for creating the ProbTarget |
CPropertyActFactory | Factory for the PropertyAction |
CPropertyAction | The base class for modifying agent properties |
CRandomGoalSelector | The random goal selector selects a goal from a goal set with uniform probability (i.e., it ignores the goal weights) |
CRandomGoalSelectorFactory | Factory for the RandomGoalSelector |
CRemoveObstacleActFactory | Factory for the RemoveObstacleSetAction |
CRemoveObstacleSetAction | Modifies the agent's obstacle set by REMOVING the given obstacle set value |
CReturnTarget | The definition of the return target |
CReturnTargetFactory | The factory for creating the ReturnTarget |
CRoadMapVCContext | The context for the RoadMapVelComponent |
CRoadMapVCFactory | Factory for the RoadMapVelComponent |
CRoadMapVelComponent | A velocity component that returns a preferred velocity whose direction and preferred speed are computed from a velocity field |
CScalePropertyActFactory | Factory for the ScalePropertyAction |
CScaleVelModifier | A velocity modifier that scales the input velocity's speed |
CScaleVMContext | The context for the ScaleVelModifier |
CScaleVMFactory | Factory for the ScaleVelModifier |
CSetGoalSelector | This is a base class – not to be instantiated. It provides the functional basis for GoalSelectors which use a GoalSet as the underlying data structure |
CSetGoalSelectorFactory | Factory for the SetGoalSelector |
CSetObstacleActFactory | Factory for the SetObstacleSetAction |
CSetObstacleSetAction | Modifies the agent's obstacle set by SETTING the given obstacle set value (i.e. overriding the old value with the new) |
CSetPropertyActFactory | Factory for the SetPropertyAction |
CSharedGoalSelector | The shared goal selector is a stub goal selector used strictly internally for bookkeeping. It is used to implement shared goal selectors between states. It is not intended to be sub-classed. |
CSharedGoalSelectorFactory | Factory for the SharedGoalSelector |
CSingleTarget | A TransitionTarget which assumes there is only one destination state |
CSpaceCondFactory | The factory for creating the SpaceCondition |
CSpaceCondition | The abstact base class for spatial conditions. This includes all conditions which define a geometric region and then determines that the condition is met by either entering or exiting the region |
CState | The basic state of the behavior finite state machine |
CStateContext | Base context for finite state machine states |
CStateDescrip | The description of a state (see State) |
CStateException | Exception class for BFSM states |
CStateFatalException | Exception thrown when the state has an error which cannot be recovered from |
CTargetFactory | A class for parsing the xml description of a TransitionTarget and instantiating particular instances |
CTask | Interface for basic FSM task |
CTaskException | Exception thrown when a task fails at doing its work. These exceptions can be logged but should not arrest execution of the simulation |
CTaskFactory | A class for parsing the xml description of a task and instantiating particular instances |
CTaskFatalException | Exception thrown when the task has an error which cannot be recovered from |
CTeleportActFactory | Factory for the TeleportAction |
CTeleportAction | Causes the agents to teleport to a new location |
CTimerCondFactory | The factory for creating the TimerCondition |
CTimerCondition | The definition of the timer condition |
CTransition | The transition between BFSM states |
CTransitionTarget | The base class for transition targets |
CVecFieldVCContext | The context for the VFVelComponent |
CVelCompContext | Base context for finite state machine velocity components |
CVelCompException | Base exception class for preferred velocity computation |
CVelCompFactory | A class for parsing the xml description of a velocity component and instantiating particular instances |
CVelCompFatalException | Exception thrown when the velocity component has an error which cannot be recovered from |
CVelComponent | The base class for computing an agent's preferred velocity |
CVelModContext | Base context for finite state machine velocity modifiers |
CVelModException | Base exception class for preferred velocity modification |
CVelModFactory | A class for parsing the xml description of a velocity MODIFIER and instantiating particular instances |
CVelModFatalException | Exception thrown when the velocity modifier has an error which cannot be recovered from |
CVelModifier | The base class for modifying preferred velocities |
CVFVCFactory | Factory for the VFVelComponent |
CVFVelComponent | A velocity component that returns a preferred velocity whose direction and preferred speed are computed from a velocity field |
CWeightedGoalSelector | The weighted goal selector selects a goal from a goal set with weighted probability (i.e., it uses the user-specified goal weights) |
CWeightedGoalSelectorFactory | Factory for the WeightedGoalSelector |
CZeroVCContext | The context for the ZeroVelComponent |
CZeroVCFactory | Factory for the ZeroVelComponent |
CZeroVelComponent | A velocity component that always returns the zero velocity |
►NMath | |
CAABBShape | Axis-aligned bounding box |
CAABBUniformPosGenerator | Generates a 2D float value uniformly distributed in an axis-aligned box (AAB) |
CCircleShape | Circle shape |
CConst2DGenerator | A 2D float generator which always returns a constant 2D vector |
CConstFloatGenerator | A FloatGenerator which returns a constant value |
CConstIntGenerator | An IntGenerator which returns a constant value |
CFloatGenerator | Generic abstract class which generates a scalar float value |
CGeometry2D | Abstract 2d Geometry class for FSM queries |
CIntGenerator | Generic abstract class which generates a scalar integer value |
CLine | Defines a directed line |
CMatrix4x4 | Basic 4x4 matrix of floats |
CNormalFloatGenerator | A FloatGenerator which returns a normally distributed value |
COBBShape | Oriented bounding box |
COBBUniformPosGenerator | Generates a 2D float value uniformly distributed in an oriented box (OB) |
CUniformFloatGenerator | A FloatGenerator which returns a uniformly distributed value within a defined range |
CUniformIntGenerator | An IntGenerator which returns a uniformly distributed value within a defined range |
CVec2DGenerator | Generic abstract class which generates a 2D vector float values |
CVector2d | Templated vector in R2 |
CVector3d | Templated vector in R3 |
CWeightedInt | A weighted integer value. Used with WeightedIntGenerator |
CWeightedIntGenerator | A number generator based on a weighted probability of a discrete value set |
CZero2DGenerator | A 2D float generator which always returns a zero |
►NSceneGraph | |
CCircle | A GLNode for drawing circles. The circle is drawn around the world space origin, lying on the x-z plane |
CContext | The base context class for defining a how events are handled. It also is responsible drawing UI elements in both screen space and in viewer world space. While the main viewer handles basic view manipulation, all other interactions should be handled with a context |
CContextResult | Defines the result of the context's consideration of user input |
CContextSwitcher | Special context for switching between multiple contexts. Each context tied to a keyboard shortcut |
CCylinder | A GLNode for drawing cylinders. The cylinder has unit radius and unit height and the bottom of the cylinder sits on the origin. The height is along the y-axis |
CGLCamera | The class for controlling the view camera: it's position, orientation field of view, projection matrix, etc |
CGLDagNode | The node that provides the basis for a "hierarchy" in the scene graph |
CGLGroundPlane | A ground plane approximation – z = 0, in world space |
CGLLight | The OpenGL light class. Defines a light for the basic OpenGL pipeline |
CGLNode | An abstact class – a generic, scene graph node |
CGLScene | The class which contains the entire drawable scene |
CSelectable | The class interface for selectable objects – objects which can be selectedc in the OpenGL context by clicking on them |
CSelectContext | A context that performs object selection by directly clicking on selectable entities in the OpenGL context |
CShape | The basic shape class - a selectable GLNode |
CSystem | An animation system. Responsible for updating the scene based based on increasing time values |
CSystemStopException | Exception class for indicating that a system is done |
CTextWriter | A singleton class responsible for writing text to an OpenGL context |
CTransform | Scene graph node which applies transforms to nodes |
CXformMatrix | The transformation matrix |
►NVis | |
CCameraParam | A set of parameters specifying a single camera |
CGLViewer | Class for defining an OpenGL Viewer |
CLapTimer | Lap timer. A timer which supports "laps" i.e., single calls which measure from the last "tick" to this tick |
CLightParam | A set of parameters specifying a single light |
CNullViewer | The off-line context for running a simulation |
CProfiler | Class for storing sets of timers for profiling aspects of the simulation |
CSampleTimer | A timer which uses a cache of values to only update its values every N calls to lap/elapsed. Useful for displaying frame rate |
CTimer | Basic timer |
CViewConfig | The specification of an OpenGL GLViewer for a scene |
CWatermark | A class for handling the watermark functionality |
CAgentEventEffect | The event effect class that operates on sets of agents |
CAgentEventTarget | The base class for all event targets which target agents |
CAgentEventTargetFactory | Factory for the AgentEventTarget |
CAgentPropertyEffect | The base class event effect changes agent properties |
CAgentPropertyEffectFactory | The factory for agent property event effects |
CAgentPropertyManipulator | Base class for manipulating agent properties in an undoable manner. The undo is limited, it only maintains knowledge of one manipulation. If multiple manipulations are applied, only the last can be undone |
CAStarMinHeap | An implementation of a min heap for A* algorithm. The heap needs to be able to restructure itself because the values of nodes IN the heap can change due to the A* algorithm |
CAttribute | An element attribute |
CAttributeDefinitionException | Exception class for attribute definition problems (i.e., using the wrong type of attribute for the wrong data-type) |
CAttributeDefinitionFatalException | The fatal attribute definition exception |
CAttributeSet | A set of attributes |
CBaseAgentContext | Context class for displaying various characteristics of the Agents::BaseAgent class |
CBoolAttribute | The class which specifies an xml attribute with a boolean-type value |
CElement | The basic interface of extendible Menge Elements |
CElementDB | The base functionality of an element database |
CElementFactory | The templated base class for a plugin element |
CEvent | The definition of a Menge event |
CEventEffect | The definition of a response to an event |
CEventEffectFactory | The base class for generating event effects |
CEventException | The base event exception |
CEventFatalException | The fatal event exception |
CEventResponse | A response to an event trigger. It combines an effect with a target |
CEventSystem | The main event engine – causes event triggers to be evaluated and effects to be applied |
CEventTarget | The base class for all event targets |
CEventTargetFactory | The base class for generating event targets |
CEventTrigger | The base class for event triggers |
CEventTriggerFactory | The base class for generating event triggers |
CFloatAttribute | The class which specifies an xml attribute with a float-type value |
CFloatDistributionAttribute | The class which specifies an xml attribute with a float distribution value |
CFunnelApex | The apex of the funnel |
CFunnelEdge | The edge of a funnel |
CFunnelPlanner | The class that implements the funnel algorithm |
CGLContextManager | Handles updating the scene graph when there is a new OpenGL context |
CGraph | A roadmap graph and the infrastructure for performing graph searches. NOTE: This implementation assumes that the graph doesn't change |
CGraphEdge | A graph edge |
CGraphVertex | A graph vertex |
CImage | Wrapper for the managed ImageData |
CImageData | Manged image data (see ManagedData) |
CIntAttribute | The class which specifies an xml attribute with a int-type value |
CIntDistributionAttribute | The class which specifies an xml attribute with an int distribution value |
CLogger | An html logger - writes messages to a formatted html file |
CManagedData | The interface for managed data (essentially smart poitners) |
CManagedDataWrapper | A wrapper for managed data - automatically handles referencing and deletion of managed data |
CMengeException | Base exception class for menge operations |
CMengeFatalException | Base class for fatal exceptions |
CNamedStateMemberTarget | Defines the target of an event effect based on membership relationship to a single named state |
CNamedStateMemberTargetFactory | The factory to generate NamedStateMemberTarget instances |
CNavMesh | The class for defining a navigation mesh. A decomposition of the free space into a connected mesh of convex (or near convex) polygons used for global planning in planar or non-planar environments |
CNavMeshEdge | The navigation mesh adjacency graph edge |
CNavMeshLocalizer | Class responsible for tracking agent relatinoships to the navigation mesh: its current location and its path |
CNavMeshLocation | Class for indicating how the location of the agent is defined. Either by a portal path or a node |
CNavMeshNode | The navigation mesh adjacency graph node. It corresponds to a convex polygon in the navigation mesh |
CNavMeshObstacle | Specification of an obstacle. It is the same as a pedModel specification but includes a pointer to a node to which it is attached |
CNavMeshPoly | The polygon used in each node of a navigation mesh graph |
CNMNodeGroup | A navigation mesh node group |
COffsetAgentPropertyEffectFactory | Factory for the OffsetPropertyEffect |
COffsetPropertyManipulator | Modifies a particular agent property based by adding the value from a distribution to the original agent parameter value |
CPathPlanner | Class for computing paths through a navigation mesh |
CPathPlannerException | Exception class for path planner |
CPathPlannerFatalException | The fatal path planner exception |
CPlugin | The base plug-in class |
CPluginEngine | The class responsible for finding, managing, and deleting plugins |
CPortal | A simple portal definition |
CPortalPath | The definition of a path through space comprising of a sequence of portals |
CPortalRoute | The definition of a route through a navigation mesh from a start to an end node |
CReadersWriterLock | The definition of a readers-writer lock |
CResource | Basic class for managing on-disk resources |
CResourceException | A base exception for resources to throw |
CResourceFatalException | The fatal resource exception |
CResourceManager | Class to handle management of on-disk resources |
CResourcePtr | Base Class providing a pointer interface to Resources |
CRoadMapPath | A path on a roadmap between vertices |
CScaleAgentPropertyEffectFactory | Factory for the ScalePropertyEffect |
CScalePropertyManipulator | Modifies a particular agent property based by multiplying the value from a distribution to the original agent parameter value |
CSetAgentPropertyEffectFactory | Factory for the SetPropertyEffect |
CSetPropertyManipulator | Modifies a particular agent property based by explicitly setting the property value from a distribution |
CSimDBException | Exception for SimulatorDB issues |
CSimDBFatalException | The fatal SimulatorDB exception |
CSimpleLock | The definition of a simple mutex-style lock |
CSimSystem | Templated class for performing simulation |
CSimSystemException | Generic exception for the SimSystem |
CSimSystemFatalException | The fatal SimSystem exception |
CSimulatorDB | The simulator database class |
CSimulatorDBEntry | An entry in the simulator database |
CSizeTAttribute | The class which specifies an xml attribute with a size_t-type value |
CStateEvtTrigger | The base class event triggers which depend on state properties |
CStateEvtTriggerFactory | The factory for state event triggers |
CStatePopIncreaseTrigger | A trigger that fires off when a state's population increases |
CStatePopIncTriggerFactory | The factory for StatePopIncreaseTrigger event triggers |
CStringAttribute | The class which specifies an xml attribute with a string-type value |
CUtilException | Exception thrown when a utility function fails. |
CUtilFatalException | Exception thrown when the utility functions have an error which cannot be recovered from |
CVec2DDistributionAttribute | The class which specifies an xml attribute with a 2D float distribution value |
CVectorField | A simple 2D vector field |
CVisAgent | The basic agent visualization class: a selectable cylinder |
CVisObstacle | A simple class for drawing a simulation obstacle (line segment). The obstacle is drawn with lines in 3D space |
CWayPortal | The basic structure defining a way "point" along a path through a navigation mesh. It consists of the navigation mesh edge to pass through and the node one should be in while heading to the edge |
►NORCA | The namespace for the ORCA local collision avoidance model |
CAgent | Defines an agent in the simulation |
CAgentInitializer | Class which determines the agent properties for each new ORCA agent |
CDBEntry | The simulator database entry for the ORCA simulator |
CSimulator | Defines the simulator operating on ORCA::Agent |
►Nos | A compilation of file system operations |
►NPedVO | Contains the specification of the pedestrian model based on Pedestrian Velocity Obstacles |
CAgent | Defines an agent in the simulation |
CAgentInitializer | Class which determines the agent properties for each new PedVO agent |
CDBEntry | The simulator database entry for the PedVO simulator |
CSimulator | Defines the simulator operating on ORCA::Agent |
CORCATypeAgentContext | Context class for displaying various aspects of the ORCA-type agent computation |
CProjectSpec | The specificaiton of a simulation project |