DetourCrowd.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
// Modified version of Recast/Detour's source file
 
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
 
#ifndef DETOURCROWD_H
#define DETOURCROWD_H
 
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "Detour/DetourLargeWorldCoordinates.h"
#include "Detour/DetourNavMesh.h"
#include "Detour/DetourNavMeshQuery.h"
#include "DetourCrowd/DetourLocalBoundary.h"
#include "DetourCrowd/DetourObstacleAvoidance.h"
#include "DetourCrowd/DetourPathCorridor.h"
#include "DetourCrowd/DetourPathQueue.h"
#include "DetourCrowd/DetourSharedBoundary.h"
#include "HAL/Platform.h"
#include "Templates/SharedPointer.h"
 
class FString;
class dtProximityGrid;
 
static const int DT_CROWDAGENT_MAX_NEIGHBOURS = 6;
 
static const int DT_CROWDAGENT_MAX_CORNERS = 4;
 
static const int DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS = 8;
 
static const int DT_CROWD_MAX_FILTERS = 16;
 
struct dtCrowdNeighbour
{
    int idx;        
    dtReal dist;        
};
 
enum CrowdAgentState
{
    DT_CROWDAGENT_STATE_INVALID,        
    DT_CROWDAGENT_STATE_WALKING,        
    DT_CROWDAGENT_STATE_OFFMESH,        
    DT_CROWDAGENT_STATE_WAITING,        
};
 
struct dtCrowdAgentParams
{
    void* userData;
 
    TSharedPtr<dtQuerySpecialLinkFilter> linkFilter;
 
    dtReal radius;                      
    dtReal height;                      
    dtReal maxAcceleration;             
    dtReal maxSpeed;                    
 
    dtReal collisionQueryRange;
 
    dtReal pathOptimizationRange;       
 
    dtReal separationWeight;
 
    dtReal avoidanceQueryMultiplier;
 
    unsigned int avoidanceGroup;
    unsigned int groupsToAvoid;
    unsigned int groupsToIgnore;
 
    unsigned short updateFlags;
 
    unsigned char obstacleAvoidanceType;    
 
    unsigned char filter;
};
 
enum MoveRequestState
{
    DT_CROWDAGENT_TARGET_NONE = 0,
    DT_CROWDAGENT_TARGET_FAILED,
    DT_CROWDAGENT_TARGET_VALID,
    DT_CROWDAGENT_TARGET_REQUESTING,
    DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE,
    DT_CROWDAGENT_TARGET_WAITING_FOR_PATH,
    DT_CROWDAGENT_TARGET_VELOCITY,
};
 
struct dtCrowdAgent
{
    dtPathCorridor corridor;
 
    dtLocalBoundary boundary;
    
    dtReal topologyOptTime;
    
    dtCrowdNeighbour neis[DT_CROWDAGENT_MAX_NEIGHBOURS];
 
    dtReal desiredSpeed;
 
    dtReal npos[3];     
    dtReal disp[3];
    dtReal dvel[3];     
    dtReal nvel[3];
    dtReal vel[3];      
 
    dtCrowdAgentParams params;
 
    dtReal cornerVerts[DT_CROWDAGENT_MAX_CORNERS*3];
 
    dtPolyRef cornerPolys[DT_CROWDAGENT_MAX_CORNERS];
 
    dtReal targetReplanTime;                
    dtReal targetPos[3];                    
    dtPolyRef targetRef;                
    dtPathQueueRef targetPathqRef;      
 
    int nneis;
 
    unsigned char cornerFlags[DT_CROWDAGENT_MAX_CORNERS];
 
    int ncorners;
    
    unsigned char targetReplan;         
    unsigned char targetState;          
 
    unsigned char active;
 
    unsigned char state;
};
 
struct dtCrowdAgentAnimation
{
    dtReal initPos[3], startPos[3], endPos[3];
    dtPolyRef polyRef;
    dtReal t, tmax;
    unsigned char active;
};
 
enum UpdateFlags
{
    DT_CROWD_ANTICIPATE_TURNS       = 1 << 0,
    DT_CROWD_OBSTACLE_AVOIDANCE     = 1 << 1,
    DT_CROWD_SEPARATION             = 1 << 2,
    DT_CROWD_OPTIMIZE_VIS           = 1 << 3,   
    DT_CROWD_OPTIMIZE_TOPO          = 1 << 4,   
    DT_CROWD_OPTIMIZE_VIS_MULTI     = 1 << 5,   
    DT_CROWD_OFFSET_PATH            = 1 << 6,   
    DT_CROWD_SLOWDOWN_AT_GOAL       = 1 << 7,   
};
 
// [UE] Flags used by boundary segments (dtLocalBoundary::Segment)
enum CrowdBoundaryFlags
{
    DT_CROWD_BOUNDARY_IGNORE = 1 << 0,
};
 
struct dtCrowdAgentDebugInfo
{
    int idx;
    dtReal optStart[3], optEnd[3];
    dtObstacleAvoidanceDebugData* vod;
    TMap<int32, FString> agentLog;
};
 
class dtCrowd
{
    int m_maxAgents;
    int m_numActiveAgents;
    dtCrowdAgent* m_agents;
    dtCrowdAgent** m_activeAgents;
    dtCrowdAgentAnimation* m_agentAnims;
    
    dtPathQueue m_pathq;
    dtSharedBoundary m_sharedBoundary;
 
    dtObstacleAvoidanceParams m_obstacleQueryParams[DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS];
    dtObstacleAvoidanceQuery* m_obstacleQuery;
    
    dtProximityGrid* m_grid;
    
    dtPolyRef* m_pathResult;
    
    dtReal m_ext[3];
    dtQueryFilter m_filters[DT_CROWD_MAX_FILTERS];
    dtQueryFilter m_raycastFilter;
    
    dtReal m_maxAgentRadius;
 
    // [UE] time between attempts to restore agents state
    dtReal m_agentStateCheckInterval;
 
    // [UE] radius multiplier for offseting path around corners
    dtReal m_pathOffsetRadiusMultiplier;
 
    // [UE] separation filter
    dtReal m_separationDirFilter;
 
    int m_maxPathResult;
 
    int m_velocitySampleCount;
 
    dtNavMeshQuery* m_navquery;
 
    // [UE] if set, path visibility optimization can't leave current area type
    bool m_raycastSingleArea;
    // [UE] if set, offmesh connections won't be cut from corridor
    bool m_keepOffmeshConnections;
    // [UE] if set, crowd agents will use early reach test
    bool m_earlyReachTest;
 
    NAVMESH_API void updateTopologyOptimization(dtCrowdAgent** agents, const int nagents, const dtReal dt);
    NAVMESH_API void updateMoveRequest(const dtReal dt);
    NAVMESH_API void checkPathValidity(dtCrowdAgent** agents, const int nagents, const dtReal dt);
 
    NAVMESH_API bool requestMoveTargetReplan(const int idx, dtPolyRef ref, const dtReal* pos);
 
    NAVMESH_API void purge();
    
public:
    NAVMESH_API dtCrowd();
    NAVMESH_API ~dtCrowd();
    
    NAVMESH_API bool init(const int maxAgents, const dtReal maxAgentRadius, dtNavMesh* nav);
 
    NAVMESH_API bool initAvoidance(const int maxNeighbors, const int maxWalls, const int maxCustomPatterns);
    
    NAVMESH_API void setObstacleAvoidanceParams(const int idx, const dtObstacleAvoidanceParams* params);
 
    NAVMESH_API const dtObstacleAvoidanceParams* getObstacleAvoidanceParams(const int idx) const;
    
    NAVMESH_API void setObstacleAvoidancePattern(int idx, const dtReal* angles, const dtReal* radii, int nsamples);
 
    NAVMESH_API bool getObstacleAvoidancePattern(int idx, dtReal* angles, dtReal* radii, int* nsamples);
 
    NAVMESH_API const dtCrowdAgent* getAgent(const int idx);
 
    NAVMESH_API const int getAgentCount() const;
    
    NAVMESH_API int addAgent(const dtReal* pos, const dtCrowdAgentParams& params, const dtQueryFilter* filter);
 
    NAVMESH_API void updateAgentParameters(const int idx, const dtCrowdAgentParams& params);
 
    NAVMESH_API bool updateAgentFilter(const int idx, const dtQueryFilter* filter);
 
    NAVMESH_API void updateAgentState(const int idx, bool repath);
 
    NAVMESH_API void removeAgent(const int idx);
    
    NAVMESH_API bool requestMoveTarget(const int idx, dtPolyRef ref, const dtReal* pos);
 
    NAVMESH_API bool requestMoveVelocity(const int idx, const dtReal* vel);
 
    NAVMESH_API bool resetMoveTarget(const int idx);
 
    NAVMESH_API bool setAgentWaiting(const int idx);
 
    NAVMESH_API bool setAgentBackOnLink(const int idx);
 
    NAVMESH_API bool resetAgentVelocity(const int idx);
 
    NAVMESH_API int getActiveAgents(dtCrowdAgent** agents, const int maxAgents);
 
    NAVMESH_API int cacheActiveAgents();
 
    NAVMESH_API void update(const dtReal dt, dtCrowdAgentDebugInfo* debug);
    
    NAVMESH_API void updateStepPaths(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepProximityData(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepNextMovePoint(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepSteering(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepAvoidance(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepMove(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepCorridor(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepOffMeshAnim(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void updateStepOffMeshVelocity(const dtReal dt, dtCrowdAgentDebugInfo* debug);
 
    NAVMESH_API void setAgentCheckInterval(const dtReal t);
 
    NAVMESH_API bool setAgentCorridor(const int idx, const dtPolyRef* path, const int npath);
 
    NAVMESH_API void setSingleAreaVisibilityOptimization(bool bEnable);
 
    NAVMESH_API void setPruneStartedOffmeshConnections(bool bRemoveFromCorridor);
 
    NAVMESH_API void setEarlyReachTestOptimization(bool bEnable);
 
    NAVMESH_API void setPathOffsetRadiusMultiplier(dtReal RadiusMultiplier);
 
    NAVMESH_API void setSeparationFilter(dtReal InFilter);
 
    NAVMESH_API bool isOutsideCorridor(const int idx) const;
 
    NAVMESH_API const dtQueryFilter* getFilter(const int idx) const;
 
    NAVMESH_API dtQueryFilter* getEditableFilter(const int idx);
 
    const dtReal* getQueryExtents() const { return m_ext; }
    
    inline int getVelocitySampleCount() const { return m_velocitySampleCount; }
    
    const dtProximityGrid* getGrid() const { return m_grid; }
 
    const dtPathQueue* getPathQueue() const { return &m_pathq; }
 
    const dtNavMeshQuery* getNavMeshQuery() const { return m_navquery; }
 
    const dtSharedBoundary* getSharedBoundary() const { return &m_sharedBoundary; }
 
    dtCrowdAgent** getActiveAgents() const { return m_activeAgents; }
 
    inline int getNumActiveAgents() const { return m_numActiveAgents; }
 
    inline int getAgentIndex(const dtCrowdAgent* agent) const  { return (int)(agent - m_agents); }
 
    const dtCrowdAgentAnimation* getAgentAnims() const { return m_agentAnims;  }
};
 
NAVMESH_API dtCrowd* dtAllocCrowd();
 
NAVMESH_API void dtFreeCrowd(dtCrowd* ptr);
 
 
#endif // DETOURCROWD_H
 
 
// This section contains detailed documentation for members that don't have
// a source file. It reduces clutter in the main section of the header.