| ►NKaim | |
| CAbstractGraphDataGenerator | Usage: AbstractGraphDataGenerator gen; gen.InitFromXxxx() gen.Generate() gen.SaveAbstractGraphData() |
| CActiveCell | This object gathers all the active NavFloors at a CellPos |
| CActiveData | This class gathers all the navigation data that are currently active in a Database |
| CAdvancedPathProgressConfig | Class that aggregates path validation minimum distances (advanced parameters) |
| CAStarQuery | Runs an A-star algorithm to find a Path through the navigation data (NavMesh & NavGraph) from a starting point to a destination, refines the path found, and fills an object of type Path |
| CAsyncQueryDispatcher | Default implementation of IAsyncQueryDispatcher |
| CAttributeGroupBlob | Contains attributes names, types and headers, and DOES NOT contain attributes values (see VisualDebugAttributeGroupValuesBlob) |
| CAttributeGroupValuesBlob | Contains attributes values and DOES NOT contain attributes names, types and headers (see VisualDebugAttributeGroupBlob) |
| CAvoidanceCollider | A Collider is a 2D circular particle with a linear velocity |
| CAvoidanceComputer | This class compute collision-free trajectories |
| CAvoidanceComputerCollectorFilter | Class used to filter potential colliders in AvoidanceComputer at SpatializedPoint collection step |
| CAvoidanceConfig | Set of parameters used to configure AvoidanceComputer |
| CAvoidanceSolver | AvoidanceSolver computes a velocity compatible with all the colliders in AvoidanceWorkspace and the NavData accordingly to TraverseLogic |
| CAvoidanceWorkspace | AvoidanceWorkspace aggregates at once: |
| CBaseAStarQuery | Base class for AstarQuery |
| CBaseBestGraphVertexPathFinderQuery | Base class for BestGraphVertexPathFinderQuery |
| CBaseBlobBuilder | BaseBlobBuilder is an abstract base class that builds a blob within a contiguous block of memory |
| CBaseDiskCanGoQuery | Base class for DiskCanGoQuery |
| CBaseDiskCastQuery | Base class for DiskCastQuery |
| CBaseDiskCollisionQuery | Base class for DiskCollisionQuery |
| CBaseDiskExpansionQuery | Base class for DiskExpansionQuery |
| CBaseFindFirstVisiblePositionOnPathQuery | Base class for FindFirstVisiblePositionOnPathQuery |
| CBaseInsidePosFromOutsidePosQuery | Base class for InsidePosFromOutsidePosQuery |
| CBaseLog | BaseLog must used instead of Kaim::Log due to parti pris for Navigation's VisualDebug |
| CBaseMultiDestinationPathFinderQuery | Base class for MultiDestinationPathFinderQuery |
| CBaseNavigationProfile | BaseNavigationProfile and its derivation NavigationProfile<TraverseLogic> is a class that simplifies the customization of the navigation |
| CBaseNearestBorderHalfEdgeFromPosQuery | Base class for NearestBorderHalfEdgeFromPosQuery |
| CBasePathFromPolylineQuery | Base class for AstarQuery |
| CBasePathProgressComputer | The abstract base class for PathProgressComputer classes |
| CBaseRayCanGoOnSegmentQuery | Base class for RayCanGoOnSegmentQuery |
| CBaseRayCanGoQuery | Base class for RayCanGoQuery |
| CBaseRayCastOnSegmentQuery | Base class for RayCastOnSegmentQuery |
| CBaseRayCastQuery | Base class for RayCastQuery |
| CBaseSegmentCanGoQuery | Base class for SegmentCanGoQuery |
| CBaseSegmentCastQuery | Base class for SegmentCastQuery |
| CBaseShortcutTrajectory | This class computes minimal trajectory made of just one velocity |
| CBaseSpatializedPointCollectorInAABBQuery | Base class for SpatializedPointCollectorInAABBQuery |
| CBaseSystem | The BaseSystem provides Gameware Navigation components with a set of objects used for memory allocation, logging, performance profiling, etc |
| CBaseSystemConfig | Set of objects and configuration parameters that are required in order to initialize the BaseSystem |
| CBestGraphVertexPathFinderQuery | This query propagates outward through the NavMesh from the starting position |
| CBlobArray | A BlobArray an array that is compatible with the blob serialization framework |
| CBlobCategory | Collection of blob types |
| CBlobFile | Reads/writes the data maintained in a blob from/to a file |
| CBlobHandler | The BlobHandler class is a top-level mechanism for serializing blobs between objects in memory and files on disk |
| CBlobRef | A BlobRef is a type of reference that is compatible with the blob serialization framework |
| CBot | This class is the world element that represent an active character in Gameware Navigation |
| CBotColors | Defines the colors used to render the Bot accordingly to its internal statuses |
| CBotConfig | Class that aggregates all parameters that allow to configure the PathFinding and the PathFollowing of a Bot |
| CBotInitConfig | Class used to provide Bot initialization parameters |
| CBotMoveOnNavMesh | This class is used to get move bots on the NavMesh without physics engine |
| CBotNavigation | Per Bot data that correspond to the usage of a NavigationProfile in a Bot |
| CBotOutput | BotOutput gathers the most important outputs of a bot for easy access |
| CBox2f | This class represents a two-dimensional axis-aligned bounding box whose dimensions are stored using floating-point numbers |
| CBox2i | This class represents a two-dimensional axis-aligned bounding box whose dimensions are stored using 32-bit integers |
| CBox2LL | Each instance of this class also maintains a count of the number of elements (or grid cells) contained by the box along its X and Y axes, accessible through the CountX() and CountY() methods |
| CBox3f | This class represents a three-dimensional axis-aligned bounding box whose dimensions are stored using floating-point numbers |
| CBoxObstacle | Each instance of the BoxObstacle class represents a dynamic, physical object in your game engine that will prevent your Bots from moving freely through its bounding box |
| CBoxObstacleInitConfig | Class used to provide BoxObstacle initialization parameters |
| CBoxObstaclesCollectionBlobBuilder | A type of blob builder that creates a BoxObstaclesCollectionBlob from a list of box BoxObstacles (Kaim::BoxObstacle) |
| CBubble | This class represents a circle with potential rotation limitation |
| CBubbleArray | This class encapsulate an array of Bubbles |
| CBubbleToCornerFunnel | Adaptive radius funnel to be used typically to string pull within a Bubble array |
| CChannel | Channels define preferred navigation areas around an original Path section on NavMesh |
| CChannelArray | This class aggregates Channels along a Path |
| CChannelComputerConfig | Class that aggregates parameters that allow to configure the channel computation of a Bot |
| CChannelDisplayConfig | Classes that configures the Channel visual debug display |
| CCheckHeaderLibDesync | This class helps to finding errors in the use of header files and libraries |
| CCircleArcSpline | The class representing a spline compounded of oriented circle arcs and straight line segments |
| CCircleArcSplineComputationQuery | Base class for CircleArcSplineComputationQuery |
| CCircleArcSplineComputer | Class used to compute a CircleArcSpline in a Channel |
| CCircleArcSplineComputerVisualDebugConfig | Class used to configure all VisualDebug components for CircleArcSpline computation |
| CCircleArcSplineSection | Class representing either an oriented circle arc or a straight line segment, to be aggregated into a CircleArcSpline |
| CClientInput | The ClientInput is a representation of the input that was supplied to the generator for a particular Kaim::GeneratorSector It contains all the input triangles and tagVolumes as provided by the the Kaim::GeneratorInputProducer to the Kaim::ClientInputConsumer and can be saved or loaded to a .ClientInput file |
| CClientInputConsumer | One of the primary components of the NavData generation system |
| CClientInputSectorDescriptor | Easy to write/read version of ClientInputSectorDescriptorBlob |
| CClientInputSectorDescriptorBlob | Set of Key-Values embedded within a ClientInput BlobAggregate (serialized form) |
| CClientInputTagVolume | Represents a volume using a two-dimensional polyline extruded vertically along the "up" axis associated to a terrain and/or a BlindData |
| CColDataSectorDescriptor | Easy to write/read version of SectorDescriptorBlob |
| CColDataSectorDescriptorBlob | Set of Key-Values embedded within in ColData BlobAggregate (serialized form) |
| CCollection | Collection is a class which is a "Collection" of elements (not sorted, not unique) |
| CColliderCollectorConfig | Class that configures how the Bot collects colliders (other bots, obstacles) around |
| CCollisionData | Collision Data that will be added to a CollisionWorld |
| CCollisionRayCastQuery | Query that performs a 3D raycast against the physical geometry in a CollisionWorld |
| CCollisionWorld | This class is a runtime container for all CollisionData that represents the world |
| CContourLineExtractor | This class takes a NavFloor and an altitude range as input and will return an array of edges that form the contour lines of the slice between altMin and altMax |
| CConverge | This class represents a three-dimensional 6 freedom degrees unit transform |
| CCoordSystem | This class maintains the mapping between the system of coordinate axes used internally within the game engine, and the system used within the Gameware Navigation engine at runtime |
| CCoordSystemConfig | A structure that sets up the mapping between the coordinate system used in the Gameware Navigation Engine and the game engine |
| CCostMultiplierSubSegment | This class represents a CostMultiplier sub-segment of a ray (within a RayCastQuery or a RayCanGoQuery, carried out against the NavMesh) |
| CCylinderObstacle | CylinderObstacles represent dynamic objects of your game engine that prevent your Bots from moving freely in a vertical cylinder volume |
| CCylinderObstacleInitConfig | Class used to provide CylinderObstacle initialization parameters |
| CDatabase | This class is a runtime container for all NavData that represents the world from the point of view of a specific type of Bots |
| CDatabaseBinding | DatabaseBinding is a collection of the databases to be used for world elements spatialization |
| CDatabaseDescriptor | Easy to write/read version of DatabaseDescriptorBlob |
| CDatabaseDescriptorBlob | Set of Key-Values embedded within genIO BlobAggregate (serialized form) |
| CDatabaseGenMetrics | This class gathers a set of generation parameters of one Database and manages the conversion between the floating-point and integer coordinate systems used internally by NavData |
| CDefaultFileOpener | Simple default implementation of an object that opens a file on disk |
| CDefaultLog | Default implementation of the Kaim::Log interface |
| CDefaultNavigationProfile | DefaultNavigationProfile |
| CDefaultPathEventListObserver | This default IPathEventListObserver does not set any PathEvent as CheckPoint |
| CDenseGrid | Container that spatialize elements in a 2d grid |
| CDiagonalStripFunnel | Basic corner-to-corner funnel to be used in standard line-of-view based browsing of diagonal strips |
| CDiskCanGoQuery | The DiskCanGoQuery tests whether a disk with a specified radius can pass from a starting point to an ending point without: |
| CDiskCastQuery | The DiskCastQuery class tests whether a disk with a specified radius (m_radius) can be cast in a specified orientation (m_normalizedDir2d) from a starting point without: |
| CDiskCollisionQuery | The DiskCollisionQuery class attempts to place the center of a disk with a specified radius (m_radius) at a specified position (m_centerPos3f), and tests whether the entire disk fits within the borders of the NavMesh without intersecting any forbidden NavTag (NavMesh borders) |
| CDiskExpansionQuery | The DiskExpansionQuery class attempts to place the center of a disk at a specified position (m_centerPos3f), and expands the radius of the disk until the disk: |
| CDisplayListManager | Game side: Manages all DisplayListData, send them to the NavigationLab |
| CDisplayListRemovalBlob | Send this blob to destroy the current displayList with id "displayListId" and eventually being associated with the worldElement with id "worldElementId" |
| CDisplayListRemovalFromNameBlob | Send this blob to destroy the current displayList with name "displayListName" and eventually being associated with the worldElement with id "worldElementId" |
| CDynamicInputCell | Used in SpatializedSectorInput to gather all triangles, from sector m_sectorGuid, that impacts the m_cellPos |
| CDynamicNavMeshQuery | The DynamicNavMeshQuery is used to recompute a NavCell impacted by newly projected TagVolumes or removed tagVolumes This query is time-sliced |
| CEndianness | Collects endianness types and utilities used in the blob serialization framework |
| CFileOpenerBase | Base interface for a class that opens a file on disk |
| CFindFirstVisiblePositionOnPathQuery | The FindFirstVisiblePositionOnPathQuery class searches for a PositionOnPath that can be reached from a provided point (m_visibilityStartPos3f) |
| CFloatStat | FloatStat maintains current, average, min, max statistics in a sliding window of frames |
| CFloorAltitudeRange | Represents the range of altitudes covered by a single NavFloorBlob |
| CFollowedCircleArcSpline | CircleArcSpline with computation information and current position of follow |
| CFunnel | Basic straight line funnel acting directly on 2D positions |
| CGameKitCrowdDispersionNavTagHashMap | Associate information to push variety into paths found to an id based on GameKitNavTag |
| CGameKitCrowdDispersionNavTagId | Used to uniquely identify GameKitNavTag, c.f. GameKitNavTag for more information |
| CGameKitNavigationProfile | GameKitNavigationProfile must be added to Kaim::World and set to Bot in order to use the GameKitPathEventListObserver so PathEvents entering a NavTag associated to a GameKitSmartObject will be declared as user checkpoints |
| CGameKitNavTag | Define an interpretation of NavTag specific to GameKit |
| CGameKitSmartObjectInterval | Defines an interval in the path of a bot where there is a smartobject |
| CGameKitTraverseLogic | Custom traverse logic to manage NavTag Layers and SmartObjects |
| CGate | This class represents Channel section limit segment. See Channel class description |
| CGenerator | The Generator is the principal class in the NavData generation system |
| CGeneratorAdvancedParameters | Used by the GeneratorParameters class to maintain a set of configuration parameters that control detailed technical aspects of the NavData generation process |
| CGeneratorBaseSystem | Helper tool that enable the user to correctly initialize the BaseSystem for generating the NavData |
| CGeneratorGuidCompound | This class is a wrapper around an array of KyGuid objects |
| CGeneratorInputOutput | Central element of the generation |
| CGeneratorInputProducer | The GeneratorInputProducer is an abstract base class for an object invoked by the NavData generation system to retrieve the geometry for which it should generate NavData |
| CGeneratorParameters | Configuration parameters that control the characteristics of the NavData created by the Generator |
| CGeneratorReport | Encapsulates a detailed report of all activities carried out during a call to the Generator::Generate(GeneratorInputOutput&) method |
| CGeneratorRunOptions | Configuration parameters that control the way in which the Generator carries out the process of generating NavData for its sectors |
| CGeneratorSector | Definition for a single sector to be treated by the Generator |
| CGeneratorSectorBlob | Used to serialize GeneratorInputOutput. Corresponds to GeneratorSector |
| CGeneratorSectorBlobBuilder | Used to serialize GeneratorInputOutput |
| CGeneratorSectorBuilder | Maintains generation data for each sector |
| CGeneratorSectorListBlob | Used to serialize GeneratorInputOutput |
| CGeneratorSectorListBlobBuilder | Used to serialize GeneratorInputOutput m_exclusiveGuids and m_sectors |
| CGeneratorSectorRefCountedUserData | Base class for the optional m_refCountedUserData that allows to refCount your user data |
| CGeneratorSectorReport | The SectorStatistics class encapsulates a detailed set of statistics about a single sector treated by the NavData generation framework |
| CGeneratorSystem | GeneratorSystem gathers everything that is global across a generation: configuration, options.. |
| CHalfEdgeIntersection | This class represents an intersection between an NavHalfEdge and a ray (within a RayCastQuery or a RayCanGoQuery, carried out against the NavMesh) |
| CHeightField | Heightfield with a uniform grid of sampled altitudes |
| CIAsyncQueryDispatcher | World::PushAsyncQuery(IQuery* query) pushes the Query in the QueryQueue |
| CIAtomicQuery | Base class for all the queries that do not need to be time-sliced |
| CIAvoidanceComputer | This interface class defines the way avoidance is computed |
| CIAvoidanceFilter | Interface class for potential collider filtering classes |
| CIAvoidanceSolver | Interface class for Avoidance solvers |
| CICollisionInterface | An abstract interface for an object that can perform collision queries |
| CIGeneratorGlue | Provides an abstract base interface for a class that the Generator can invoke in order to retrieve objects that implement specific interfaces |
| CIMessageReceiver | IMessageReceiver defines an interface for objects that are called to process blobs of data sent through VisualDebug |
| CIMovePositionOnLivePathPredicate | Interface used to verify a PositionOnPath can be moved forward along the Path |
| CIndexedMesh | 3D Triangle Mesh with Indexing |
| CInputTileImprint | Relevant if m_doEnableLimitedMemoryMode is true, maintains the per InputTile information that will allows to load the InputCellBlob from file only when it's necessary |
| CInsidePosFromOutsidePosQuery | The InsidePosFromOutsidePosQuery class finds a valid position inside the boundaries of the NavMesh, at a specified distance from the NavMesh boundary (by boundary we mean hole in the NavMesh |
| CIntermediateFilesConfig | Used by GeneratorRunOptions to store configuration parameters that control whether or not the Generator writes different types of intermediate data to files on disk, where, and how |
| CIOnDone | Small interface class that you have to derive from and set to an IQuery to get the IOnDone::OnDone() function called during the World::Update() (in FlushQueries() step) if the query has been completed |
| CIParallelElementFunctor | Provides an abstract base interface for an object that treats an element of data that can be passed to an object that derives from IParallelForInterface |
| CIParallelForInterface | Provides an abstract base interface for an object that can treat computational jobs in parallel |
| CIPathEventListObserver | IPathEventListObservers are called when related PathEventList has just been created or is about to be destroyed |
| CIPathFinderQuery | Base class for all pathfinder queries |
| CIPerfMarkerInterface | An abstract interface for an object that can respond to performance tracking markers |
| CIPositionOnPathValidator | Interface class for PositionOnPath validation classes |
| CIQuery | Abstract class for all queries |
| CITimeSlicedQuery | Base class for all the queries that need to be time-sliced |
| CItinerary | An itineray is split PathEventIntervalpath where each edge on NavMesh or graph contains a navtag, while path edges can cross multiple navtags |
| CIVisualGeometry | TODO Update IVisualGeometry is an abstract base class for an object that accepts triangles, lines and texts from a class that that derives from IVisualGeometryBuilder, and has be initially designed to manage the rendering of those triangles/lines/texts in the game engine |
| CIVisualGeometryFactory | IVisualGeometryFactory is an abstract base class for an object that accepts that can instantiate objects of your own implementation of IVisualGeometry This class cannot be used as-is |
| CKyArray | General purpose array for movable objects that require explicit construction/destruction |
| CKyArrayDH | General purpose array for movable objects that require explicit construction/destruction |
| CKyArrayDH_POD | General purpose array for movable objects that DOES NOT require construction/destruction |
| CKyArrayLH | General purpose array for movable objects that require explicit construction/destruction |
| CKyArrayLH_POD | General purpose array for movable objects that DOES NOT require construction/destruction |
| CKyArrayPOD | General purpose array for movable objects that DOES NOT require construction/destruction |
| CKyGuid | Globally unique ID |
| CLivePath | This class aggregates a Path and all runtime related stuff namely the PathValidityInterval |
| CLocalCostAwareTraverseLogic | LocalCostAwareTraverseLogic is a wrapper around the traverse logic set by the user |
| CLodMaxBlob | Send this blob to display a shape saying that the visual element with id m_visualDebugId is at LOD max Send visualDebugIdRemovalBlob with this same visualDebugId and blobType LodMaxBlob::GetBlobType() to stop displaying this shape when the lod is back to default |
| CMatrix3x3f | 3x3 matrix |
| CMonodirectionalRayCanGoQuery | The MonodirectionalRayCanGoQuery is an internal version of the RayCanGoQuery that is able test navTag switch along the ray |
| CMoveOnNavMeshQuery | This class is used to get move bots on the NavMesh without physics engine |
| CMoveToNavTagEntryPositionOnPathPredicate | This predicates allows Move forward to next entry or backward to previous entry of the given NavTag |
| CMoveToNavTagExitPositionOnPathPredicate | This predicates allows Move forward to next entry or backward to previous entry of the given NavTag |
| CMultipleFloorTrianglesFromPosQuery | Takes a position in 3D space (m_inputPos3f), and finds the triangles in the NavMesh that lie at the same (X,Y) coordinates |
| CNavCell | This class is a runtime wrapper of a NavCellBlob |
| CNavCellBlob | The NavCellBlob contains the NavMesh static data of a NavMeshElement at a CellPos |
| CNavCellGrid | This class is an internal class used to manage all the NavCell in a grid |
| CNavCellPosInfo | This object gather all the data located at a CellPos in the CellPos-bases grid of the NavCellGrid object |
| CNavData | Object containing navigation data that will be added to one Database |
| CNavFloor | This class is a runtime wrapper of a NavFloorBlob, it gathers all the runtime information associated to a NavFloor such links to other NavFloors, SpatializedPoint spatialized in this NavFloor.. |
| CNavFloorAABB | Represents the integer axis-aligned bounding box of a NavFloor |
| CNavFloorBlob | The NavFloorBlob contains a connected and not overlapping part of triangle mesh static data within a NavCellBlob |
| CNavFloorBoxBlob | Blob to visual debug NavFloor information |
| CNavFloorPtr | Each instance of this class uniquely identifies a single NavFloor |
| CNavFloorRawPtr | Each instance of this class uniquely identifies a single NavFloor |
| CNavGenProj | Representation of the input data required for the standalone NavData generation tools supplied with Gameware Navigation to generate NavData for a terrain |
| CNavGenProjClientInput | An instance of this class is used to represent each input geometry file in a NavGenProj |
| CNavGenProjConfig | This class is used by the NavGenProj to store configuration parameters required by the NavData generation process |
| CNavGenProjGeometry | An instance of this class is used to represent each input geometry file in a NavGenProj |
| CNavGenProjMirrorOptions | This class is used to store parameters if a sector must be mirrored cf |
| CNavGenProjPdgInput | An instance of this class is used to represent each input sectorInput file in a NavGenProj |
| CNavGenProjSector | An instance of this class is used to represent each input geometry file in a NavGenProj |
| CNavGenProjSeedPoint | An instance of this class is used to represent each seedpoint in a NavGenProj |
| CNavGenProjTagVolume | An instance of this class is used to represent each tag volume in a NavGenProj |
| CNavGenProjTerrainTypeMaterial | Associate a Material with a TerrainType |
| CNavGraph | This class is a runtime wrapper of a NavGraphBlob, it gathers all the runtime information associated to a NavFloor such links to other NavFloors, SpatializedPoint spatialized in this NavFloor.. |
| CNavGraphBlob | The NavGraphBlob contains the static data of a NavGraph |
| CNavGraphBlobBuilder | This class allows you to build a NavGraph, which you can then add to the NavData for a sector |
| CNavGraphEdgePtr | Each instance of this class uniquely identifies a single and mono-directionnal NavGraphEdge in a NavGraph |
| CNavGraphEdgeRawPtr | Each instance of this class uniquely identifies a single NavGraphEdge in a NavGraph |
| CNavGraphPtr | This class uniquely identifies a single NavGraph |
| CNavGraphRawPtr | This class uniquely identifies a NavGraph that has been loaded |
| CNavGraphVertexPtr | Each instance of this class uniquely identifies a single NavGraphVertex in a NavGraph |
| CNavGraphVertexRawPtr | Each instance of this class uniquely identifies a single NavGraphVertex in a NavGraph |
| CNavHalfEdge | Each instance of NavHalfEdge represents a single edge of a single triangle within the NavMesh |
| CNavHalfEdgePtr | Each instance of this class uniquely identifies a single NavHalfEdge in a NavFloor |
| CNavHalfEdgeRawPtr | Each instance of this class uniquely identifies a singleNavHalfEdge in a NavFloor |
| CNavigationProfile | BaseNavigationProfile and its derivation NavigationProfile<TraverseLogic> is a class that simplifies the customization of the navigation |
| CNavMeshElement | This class is a runtime wrapper of a NavMeshElementBlob |
| CNavMeshElementBlob | The NavMeshElementBlob contains the NavMesh static data (a set of NavCellBlob) for an element (a GuidCompound) within a sector |
| CNavMeshElementManager | This class is a runtime container for the all NavMeshElement that are created from the NavMeshElementBlob added in this Database |
| CNavMeshGenParameters | This object indicates the settings used to generate the NavMeshElementBlob, and thereby the physical characteristics and movement model of the characters expected to use the NavMesh at runtime |
| CNavTagMovePositionOnPathPredicate | Default implementation of IMovePositionOnPathPredicate interface based on NavTag |
| CNavTagPtr | Each instance of this class uniquely identifies a single NavFloor |
| CNavTagSubSegment | This class represents a NavTag sub-segment of a ray (within a RayCastQuery or a RayCanGoQuery, carried out against the NavMesh) |
| CNavTrianglePtr | Each instance of this class uniquely identifies a single NavTriangle in a NavFloor |
| CNavTriangleRawPtr | Each instance of this class uniquely identifies a single NavTriangle in a NavFloor |
| CNavVertex | Represents a single vertex that forms the corner of at least one NavMesh triangle |
| CNearestBorderHalfEdgeFromPosQuery | The NearestBorderHalfEdgeFromPosQuery class finds the NavMesh border nearest a specified 3D position (m_inputPos3f) |
| CObjFileReader | A basic parser of .obj files in text format able to read triangles |
| COBJProducer | Concrete implementation of GeneratorInputProducer that can read the triangles contained in a .obj file, and pass it to the ClientInputConsumer |
| COrientedBox2d | This class represents a three-dimensional bounding box with a free orientation on the (X,Y) plane |
| ►CPath | The class representing a path |
| CCreateConfig | A class that configures the creation of a Path |
| CPathEvent | A PathEvent is a particular PositionOnPath which feature is specified by a PathEventType |
| CPathEventInterval | This class represents an interval between two PathEvents within a PathEventList |
| CPathEventList | PathEventList aggregates all PathEvents and PathEventIntervals in a PathValidityInterval |
| CPathFinderConfig | Class that aggregates most important parameters that allow to configure the PathFinding of a Bot |
| CPathFinderQueryUtils | This class is an helper used internaly by the PathFinder Queries to factorize Code |
| CPathProgressComputer | PathProgressComputer maintains the progress of a Bot along a Path |
| CPathProgressConfig | Class that aggregates parameters that allow to configure the progress of a Bot on its path |
| CPathValidityInterval | Maintains runtime validity information on a given Path |
| CPerformQueryStatistics | This class is not instantiated in databases when KY_BUILD_SHIPPING is defined It contains statistics on calls to PerformQuery() or PerformQueryWithInputCoordPos() |
| CPointOfInterest | PointOfInterest is a tagged position spatialized into the NavMesh |
| CPointOfInterestInitConfig | Class used to provide PointOfInterest initialization parameters |
| CPositionOnCircleArcSpline | Maintains a position moving along a given CricleArcSpline |
| CPositionOnCircleArcSplineSection | Maintains a position moving along a given CricleArc |
| CPositionOnLivePath | This class aggregates all necessary information to describe a position on a LivePath, namely: |
| CPositionOnPath | This class aggregates all necessary information about a position on a Path, namely: |
| CPositionOnPathCheckPointValidator | Default implementation of IPositionOnPathValidator interface that use Bot::HasReachedPosition() function and BotConfig::m_checkPointRadius |
| CProfiler | Small utility class atop Kaim::Timer to profile easily |
| CQueryDynamicOutput | This class gather the data encountered along some query process |
| CQueryQueue | QueryQueue processes queries in an asynchronous, time-sliced way, within a QueryQueueArray |
| CQueryQueueArray | QueryQueueArray processes queries in an asynchronous, time-sliced way |
| CQueryQueueCommand | Class use internal by the QueryQueue to postpone Push/Cancel of Queries until next FlushCommands() step of the World::Update() |
| CQueryQueueConfig | Class used to provide QueryQueue initialization parameters |
| CQueryQueueStats | This class is used by the Visual Debug system to profileQueryQueue |
| CQueryUtils | This class is an helper used internally by the Queries to factorize Code that is used in many Queries |
| CRadiusProfile | RadiusProfile is an array of preferred radii |
| CRadiusProfileArray | CircleArcSpline computer can compute several CircleArcSplines each corresponding to a specific RadiusProfile |
| CRadiusProfileCircleArcSplineComputerOutput | Class aggregating a CircleArcSpline and the corresponding computation result |
| CRawHalfEdgeIntersection | And then finally stored as NavTagSubSegment in the QueryDynamicOutput. see HalfEdgeIntersection for detai |
| CRawNavTagSubSegment | This class is a "volatile" version of the NavTagSubSegment class |
| CRayCanGoOnSegmentQuery | The RayCanGoOnSegmentQuery class tests whether or not a ray (with a width of 0) can pass along a straight line segment from a along an edge going from m_segmentStartPos3f to m_segmentEndPos3f, without : |
| CRayCanGoQuery | The RayCanGoQuery class tests whether or not a ray (with a width of 0) can pass along a straight line segment from a starting point to an ending point without: |
| CRayCastFull3dQuery | RayCast in full 3d useful for implementing picking on NavMesh |
| CRayCastOnSegmentQuery | The RayCastOnSegmentQuery class tests whether a ray (with a width of 0) can be cast from a starting point (m_startPos3f) along an edge going from m_segmentStartPos3f to m_segmentEndPos3f, without : |
| CRayCastQuery | The RayCastQuery class tests whether a ray (with a width of 0) can be cast from a starting point (m_startPos3f) in a specified direction (#maxMove2D) without: |
| CRayQueryUtils | This class is an helper used internaly to factorize code of Ray queries (RayCanGoQuery, RayCastGoQuery, ...) |
| CScopedDisplayList | ScopedDisplayList is used to push text, lines or shapes for rendering in the NavigationLab e.g |
| CScopedPerformedQueryCounter | This class is used in PerformQuery() or PerformQueryWithInputCoordPos() functions to count the number of query performed |
| CScopedSetPathNavigationProfile | Utility class used to set to the SetNavigationProfileId of the path easily created on the stack at the beginning of the PathFinder::Advance() implementations |
| CSectorDescriptor | Easy to write/read version of SectorDescriptorBlob |
| CSectorDescriptorBlob | Set of Key-Values embedded within in NavData BlobAggregate (serialized form) |
| CSectorInputData | Maintains the InputCellBlobs spatialized per CellPos for 1 SectorInput |
| CSegmentCanGoQuery | The SegmentCanGoQuery class tests whether a line segment-with a specified half-width (m_radius)-can move along a straight line segment from a starting point to an ending point without: |
| CSegmentCastQuery | The SegmentCastQuery class casts a line segment in a given direction, and records any collisions it detects along the way |
| CSharedPoolList | SharedPoolList represents an ordered list of elements of a single type, drawn as needed from a pre-allocated pool that you provide |
| CShortcutTrajectory | This class computes minimal trajectory made of just one velocity |
| CShortcutTrajectoryConfig | Set of parameters used by the ShortcutTrajectory and TargetOnPathComputer classes to update Bot target on path position |
| CSimpleTraverseLogic | SimpleTraverseLogic defines all the functions that are potentially called in the PathFinding and PathFollowing system when there is not not customization of the cost at all |
| CSpatializedCylinder | Internal representation of world elements, using a vertical cylinder shape |
| CSpatializedCylinderInitConfig | Class used to initialize a SpatializedCylinder |
| CSpatializedPoint | Internal class used for point spatialization in NavData |
| CSpatializedPointCollectorInAABBQuery | The SpatializedPointCollectorInAABBQuery class retrieves all SpatializedPoints within an Axis-Aligned Bounding Box (AABB) that can be reached navigating from a specified starting point, and stores them in a QueryDynamicOutput object |
| CSpatializedPointInitConfig | Class used to initialize a SpatializedPoint |
| CSPL_ConstIterator | Const iterator on SharedPoolList nodes (SPL stands for SharedPoolList) |
| CSPL_Iterator | Iterator on SharedPoolList nodes (SPL stands for SharedPoolList) |
| CSplineComputationConfigBlob | Class that configures Spline geometric parameters |
| CSplineTrajectory | SplineTrajectory computes a CircleArcSpline that allows to anticipate and adapt the velocity in the turns |
| CSplineTrajectoryConfig | Class that configures how the trajectory is computed from the Channel |
| CSplineTrajectoryConfigBlob | Class that configures how the trajectory is computed from the Channel |
| CSPListNode | This is the list node used in SharedPoolList implementation (SP stands for SharedPool) |
| CStraightMemoryHeapMalloc | Multi-platform abstraction of malloc/free/realloc Note that this is used only by the generation through MemoryHeap and MemoryHeap::Realloc doesn't maintain alignment! |
| CStraightSysAllocMalloc | Multi-platform abstraction of malloc/free/realloc Note that this is used via GeneratorSysAlloc and it requires to maintain alignment |
| CStringPuller | Computes a StringPulledBubbleList from the provided array of bubbles |
| CStringUtils | Utility functions for manipulating strings |
| CSysAlloc | Interface for allocating and freeing memory |
| CSysAllocBase | A base class for an object that manages memory allocations and de-allocations |
| CSysAllocBase_SingletonSupport | Adds to the SysAlloc class support for restricting instantiation to a single object |
| CSysAllocMalloc | This implementation of SysAlloc is used by default by the BaseSystem to allocate and free memory, if you do not set up the BaseSystem with your own custom implementation of SysAlloc |
| CTagVolume | This class represents runtime-defined volumes with customized NavTag |
| CTagVolumeDatabaseData | Each TagVolume instance aggregates one instance of this class to maintain its spatialization information in all Database it is bound to |
| CTagVolumeInitConfig | Class used to provide TagVolume initialization parameters |
| CTagVolumeTrigger | TagVolumeTrigger is dedicated to TagVolume creation / removal management |
| CTargetOnPathComputer | This class updates Bot's target on path so that: |
| CThinCapsuleWithExtentOffset | Particuliar class used to represent the ThinCapsule for QueryUtils::IsHalfEdgeCompatibleWithThinCapsule() |
| CTrackedCollection | TrackedCollection is a class which is a "Collection" of T=C* or T = Ptr< C > (not sorted, not unique) |
| CTrajectory | This class computes the trajectory either with ShortcutTrajectory or with SplineTrajectory |
| CTransform | This class represents a three-dimensional 6 freedom degrees unit transform |
| CTraversalParameters | An internal class that stores parameters used to control the propagation of traversals through the NavMesh |
| CTraverseLogicObsoleteChecker | This class is used in order to check that an inherited TraverseLogic is not implementing an obsolete function! It is systematically done when adding a NavigationProfile to the World |
| CTraverseLogicWithCostMultiplerPerNavTag | TraverseLogicWithCostMultiplerPerNavTag defines all the functions that are potentially called in the PathFinding and PathFollowing system when there the cost need to be customized according to the navTag |
| CTraverseLogicWithCostPerTriangle | TraverseLogicWithCostMultiplerPerNavTag defines all the functions that are potentially called in the PathFinding and PathFollowing system when there the cost need to be customized according to the navTag |
| CTriangle3f | This class represents a triangle in three-dimensional space, whose dimensions are stored using float values |
| CTriangle3i | This class represents a triangle in three-dimensional space, whose dimensions are stored using integer values |
| CTriangleFromPosAndTriangleSeedQuery | Finds the nearest triangle in the NavMesh that covers the same (X,Y) coordinates as a specified position in the 3D space (m_inputPos3f) |
| CTriangleFromPosQuery | Takes a position in the 3D space (m_inputPos3f), and finds the nearest triangle in the NavMesh that covers the same (X,Y) coordinates |
| CVec2f | This class defines a two-dimensional vector whose coordinates are stored using floating-point numbers |
| CVec2i | This class defines a two-dimensional vector whose coordinates are stored using 32-bit integers |
| CVec2LL | This class defines a two-dimensional vector whose coordinates are stored using 64-bit integers |
| CVec3f | This class defines a three-dimensional vector whose coordinates are stored using floating-point numbers |
| CVec3i | This class defines a three-dimensional vector whose coordinates are stored using 32-bit integers |
| CVersion | This class provides information about Gameware Navigation version |
| CVisualColor | Represents a single RGBA color |
| CVisualDebugAttributeGroup | A group of Key / valuetype / arrayof values, where the keys and types are created once, and values updated whenever |
| CVisualDebugClient | Manages the retrieval of data from a VisualDebugServer running in the game engine |
| CVisualDebugDataRemovalBlob | Send this blob to destroy the current visual debug data of type "blobType" in the visual debug element with id "visualDebugId" |
| CVisualDebugServer | The VisualDebugServer manages the sending of data to clients |
| CVisualDebugServerConfig | Configure the VisualDebugServer |
| CVisualGeometrySetupConfig | Used to configure an object that derives from IVisualGeometry |
| CVisualTriangle | Represents a single triangle that can be rendered by a class that derives from IVisualGeometry |
| CWorld | This class is a runtime container for Gameware Navigation WorldElements such as NavData, Bots, BoxObstacles, TagVolumes.. |
| CWorldElement | Base internal class used to represent elements that can be added to a World, such as instances of Database, Bot, BoxObstacle, CylinderObstacle, TagVolume.. |
| CWorldIntegerPos | Utilities for dealing with NavData coordinates, which are expressed in a world space based on integers |
| ►NKyGlue | |
| CDefaultGeneratorGlue | Default implementation of a class that hooks a third-party parallel processing framework to the NavData generation system |
| CDefaultGuidGeneratorInterface | Generates GUIDs automatically on Windows, Mac OS X and Linux platforms by calling system functions |
| CTbbParallelForInterface | This implementation of Kaim::IParallelForInterface uses the open-source Threaded Building Blocks (TBB) libraries from Intel to parallelize NavData generation across all available processors on the computer |
| CTbbTlsAlloc | This implementation of Kaim::ITlsAlloc uses the scalable memory allocation functions provided with the open-source Threaded Building Blocks (TBB) libraries from Intel |
| ►NLabEngine | |
| CMirroredOBJProducer | Concrete implementation of GeneratorInputProducer that can read the triangles contained in a .obj file |
| CCollisionInterface | Implementation of ICollisionInterface that uses Bullet |
| CPerfMarkerInterface | Implementation of IPerfMarkerInterface that uses snTuner and PIX |