DetourNavMeshQuery.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 DETOURNAVMESHQUERY_H
#define DETOURNAVMESHQUERY_H
 
#include "CoreMinimal.h"
#include "Detour/DetourAlloc.h"
#include "Detour/DetourCommon.h"
#include "Detour/DetourLargeWorldCoordinates.h"
#include "Detour/DetourNavMesh.h"
#include "Detour/DetourStatus.h"
#include "Misc/AssertionMacros.h"
 
//@UE BEGIN
#define WITH_FIXED_AREA_ENTERING_COST 1
 
// Note poly costs are still floats in UE so we are using FLT_MAX as unwalkable still.
#define DT_UNWALKABLE_POLY_COST FLT_MAX
//@UE END
 
// By default dtQueryFilter will use virtual calls.
// On certain platforms indirect or virtual function call is expensive. The default
// setting is to use non-virtual functions, the actual implementations of the functions
// are declared as inline for maximum speed. 
// To avoid virtual calls create dtQueryFilter with inIsVirtual = false.
 
// Special link filter is custom filter run only for offmesh links with assigned UserId
// Used by smart navlinks in UE
//
struct dtQuerySpecialLinkFilter
{
    virtual ~dtQuerySpecialLinkFilter() {}
 
    
    virtual bool isLinkAllowed(const unsigned long long int UserId) const { return true; }
 
    UE_DEPRECATED(5.3, "LinkIds are now based on a 64 bit uint. Use the version of this function that takes an unsigned long long int")
    virtual bool isLinkAllowed(const int UserId) const final { return true; }
 
    virtual void initialize() {}
};
 
// [UE: moved all filter variables to struct, DO NOT mess with virtual functions here!]
struct dtQueryFilterData
{
    dtReal m_areaCost[DT_MAX_AREAS];        
#if WITH_FIXED_AREA_ENTERING_COST
    dtReal m_areaFixedCost[DT_MAX_AREAS];
#endif // WITH_FIXED_AREA_ENTERING_COST
    dtReal heuristicScale;              
    dtReal lowestAreaCost;
 
    unsigned short m_includeFlags;      
    unsigned short m_excludeFlags;      
 
    bool m_isBacktracking;
    //@UE BEGIN
    bool m_shouldIgnoreClosedNodes;
    //@UE END
 
    NAVMESH_API dtQueryFilterData();
    
    NAVMESH_API bool equals(const dtQueryFilterData* other) const;
    NAVMESH_API void copyFrom(const dtQueryFilterData* source);
};
 
class dtQueryFilter
{
protected:
    dtQueryFilterData data;
    bool isVirtual;
    
public:
    dtQueryFilter(bool inIsVirtual = true) : isVirtual(inIsVirtual)
    {}
    virtual ~dtQueryFilter() {}
    
protected:
 
    inline bool passInlineFilter(const dtPolyRef ref,
        const dtMeshTile* tile,
        const dtPoly* poly) const
    {
        return (poly->flags & data.m_includeFlags) != 0 && (poly->flags & data.m_excludeFlags) == 0
            && (data.m_areaCost[poly->getArea()] < DT_UNWALKABLE_POLY_COST)
#if WITH_FIXED_AREA_ENTERING_COST
            && (data.m_areaFixedCost[poly->getArea()] < DT_UNWALKABLE_POLY_COST)
#endif // WITH_FIXED_AREA_ENTERING_COST
            ;
    }
 
    virtual bool passVirtualFilter(const dtPolyRef ref,
        const dtMeshTile* tile,
        const dtPoly* poly) const
    {
        return passInlineFilter(ref, tile, poly);
    }
 
public:
    bool getIsVirtual() const { return isVirtual; }
    
    inline bool passFilter(const dtPolyRef ref,
                            const dtMeshTile* tile,
                            const dtPoly* poly) const
    {
        return !isVirtual ? passInlineFilter(ref, tile, poly) : passVirtualFilter(ref, tile, poly);
    }
 
protected:
 
    inline dtReal getInlineCost(const dtReal* pa, const dtReal* pb,
        const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
        const dtPolyRef curRef, const dtMeshTile* curTile, const dtPoly* curPoly,
        const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const
    {
#if WITH_FIXED_AREA_ENTERING_COST
        const dtReal areaChangeCost = nextPoly != 0 && nextPoly->getArea() != curPoly->getArea()
            ? data.m_areaFixedCost[nextPoly->getArea()] : 0.f;
 
        return dtVdist(pa, pb) * data.m_areaCost[curPoly->getArea()] + areaChangeCost;
#else
        return dtVdist(pa, pb) * data.m_areaCost[curPoly->getArea()];
#endif // #if WITH_FIXED_AREA_ENTERING_COST
    }
 
    virtual dtReal getVirtualCost(const dtReal* pa, const dtReal* pb,
        const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
        const dtPolyRef curRef, const dtMeshTile* curTile, const dtPoly* curPoly,
        const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const
    {
        return getInlineCost(pa, pb,
            prevRef, prevTile, prevPoly,
            curRef, curTile, curPoly,
            nextRef, nextTile, nextPoly);
    }
 
//@UE BEGIN Adding support for LWCoords.
#if !DT_LARGE_WORLD_COORDINATES_DISABLED
    // This function is deprecated call the version on this function that takes FReal
    virtual float getVirtualCost(const float* pa, const float* pb,
        const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
        const dtPolyRef curRef, const dtMeshTile* curTile, const dtPoly* curPoly,
        const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const final
    {
        check(false); // This function is deprecated use the version of this function that takes FReal
        return 0.f;
    }
#endif
//@UE END Adding support for LWCoords.
 
public:
    inline dtReal getCost(const dtReal* pa, const dtReal* pb,
                          const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
                          const dtPolyRef curRef, const dtMeshTile* curTile, const dtPoly* curPoly,
                          const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const
    {
        return !isVirtual ? getInlineCost(pa, pb, prevRef, prevTile, prevPoly, curRef, curTile, curPoly, nextRef, nextTile, nextPoly)
            : getVirtualCost(pa, pb, prevRef, prevTile, prevPoly, curRef, curTile, curPoly, nextRef, nextTile, nextPoly);
    }
 
 
    inline dtReal getAreaCost(const int i) const { return data.m_areaCost[i]; }
 
    inline void setAreaCost(const int i, const dtReal cost) { data.m_areaCost[i] = cost; data.lowestAreaCost = dtMin(data.lowestAreaCost, cost); }
 
//@UE BEGIN
    inline const dtReal* getAllAreaCosts() const { return data.m_areaCost; }
    
#if WITH_FIXED_AREA_ENTERING_COST
    inline dtReal getAreaFixedCost(const int i) const { return data.m_areaFixedCost[i]; }
 
    inline void setAreaFixedCost(const int i, const dtReal cost) { data.m_areaFixedCost[i] = cost; }
 
    inline const dtReal* getAllFixedAreaCosts() const { return data.m_areaFixedCost; }
#endif // WITH_FIXED_AREA_ENTERING_COST
 
    inline dtReal getModifiedHeuristicScale() const { return data.heuristicScale * ((data.lowestAreaCost > 0) ? data.lowestAreaCost : 1.0f); }
 
    inline dtReal getHeuristicScale() const { return data.heuristicScale; }
 
    inline void setHeuristicScale(const dtReal newScale) { data.heuristicScale = newScale; }
 
    inline bool isValidLinkSide(const unsigned char side) const 
    { 
        return (side & DT_LINK_FLAG_OFFMESH_CON) == 0 || (side & DT_LINK_FLAG_OFFMESH_CON_BIDIR) != 0
            || (data.m_isBacktracking ? (side & DT_LINK_FLAG_OFFMESH_CON_BACKTRACKER) != 0
                : (side & DT_LINK_FLAG_OFFMESH_CON_BACKTRACKER) == 0);
    }
 
    inline void setIsBacktracking(const bool isBacktracking) { data.m_isBacktracking = isBacktracking; }
 
    inline bool getIsBacktracking() const { return data.m_isBacktracking; }
 
    inline void setShouldIgnoreClosedNodes(const bool shouldIgnore) { data.m_shouldIgnoreClosedNodes = shouldIgnore; }
 
    inline bool getShouldIgnoreClosedNodes() const { return data.m_shouldIgnoreClosedNodes; }
//@UE END
 
    inline unsigned short getIncludeFlags() const { return data.m_includeFlags; }
 
    inline void setIncludeFlags(const unsigned short flags) { data.m_includeFlags = flags; }
 
    inline unsigned short getExcludeFlags() const { return data.m_excludeFlags; }
 
    inline void setExcludeFlags(const unsigned short flags) { data.m_excludeFlags = flags; }
 
 
    inline bool equals(const dtQueryFilter* other) const { return data.equals(&(other->data)); }
    inline bool equals(const dtQueryFilter& other) const { return data.equals(&(other.data)); }
 
    inline void copyFrom(const dtQueryFilter* other) { data.copyFrom(&(other->data)); }
    inline void copyFrom(const dtQueryFilter& other) { data.copyFrom(&(other.data)); }
 
};
 
struct dtQueryResultPack
{
    dtPolyRef ref;
    dtReal cost;
    dtReal pos[3];
    unsigned int flag;
 
    dtQueryResultPack() : ref(0), cost(0), flag(0) {}
    dtQueryResultPack(dtPolyRef inRef, dtReal inCost, const dtReal* inPos, unsigned int inFlag);
};
 
struct dtQueryResult
{
    inline void reserve(int n) { data.resize(n); data.resize(0); }
    inline int size() const { return data.size(); }
 
    inline dtPolyRef getRef(int idx) const { return data[idx].ref; }
    inline dtReal getCost(int idx) const { return data[idx].cost; }
    inline const dtReal* getPos(int idx) const { return data[idx].pos; }
    inline unsigned int getFlag(int idx) const { return data[idx].flag; }
    NAVMESH_API void getPos(int idx, dtReal* pos);
 
    NAVMESH_API void copyRefs(dtPolyRef* refs, int nmax);
    NAVMESH_API void copyCosts(dtReal* costs, int nmax);
    NAVMESH_API void copyPos(dtReal* pos, int nmax);
    NAVMESH_API void copyFlags(unsigned char* flags, int nmax);
    NAVMESH_API void copyFlags(unsigned int* flags, int nmax);
 
protected:
    dtChunkArray<dtQueryResultPack> data;
 
    inline int addItem(dtPolyRef ref, dtReal cost, const dtReal* pos, unsigned int flag) { data.push(dtQueryResultPack(ref, cost, pos, flag)); return data.size() - 1; }
 
    inline void setRef(int idx, dtPolyRef ref) { data[idx].ref = ref; }
    inline void setCost(int idx, dtReal cost) { data[idx].cost = cost; }
    inline void setFlag(int idx, unsigned int flag) { data[idx].flag = flag; }
    NAVMESH_API void setPos(int idx, const dtReal* pos);
 
    friend class dtNavMeshQuery;
};
 
class dtNavMeshQuery
{
public:
    NAVMESH_API dtNavMeshQuery();
    NAVMESH_API ~dtNavMeshQuery();
    
    NAVMESH_API dtStatus init(const dtNavMesh* nav, const int maxNodes, dtQuerySpecialLinkFilter* linkFilter = 0);
 
    NAVMESH_API void updateLinkFilter(dtQuerySpecialLinkFilter* linkFilter);
    
    // /@{
 
    NAVMESH_API dtStatus findPath(dtPolyRef startRef, dtPolyRef endRef,
                      const dtReal* startPos, const dtReal* endPos, const dtReal costLimit, //@UE
                      const dtQueryFilter* filter,
                      dtQueryResult& result, dtReal* totalCost) const;
    
    NAVMESH_API dtStatus findStraightPath(const dtReal* startPos, const dtReal* endPos,
                              const dtPolyRef* path, const int pathSize,
                              dtQueryResult& result, const int options = 0) const;
 
 
    NAVMESH_API dtStatus initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef,
                                const dtReal* startPos, const dtReal* endPos, const dtReal costLimit, const bool requireNavigableEndLocation, //@UE
                                const dtQueryFilter* filter);
 
    NAVMESH_API dtStatus updateSlicedFindPath(const int maxIter, int* doneIters);
 
    NAVMESH_API dtStatus finalizeSlicedFindPath(dtPolyRef* path, int* pathCount, const int maxPath);
    
    NAVMESH_API dtStatus finalizeSlicedFindPathPartial(const dtPolyRef* existing, const int existingSize,
                                           dtPolyRef* path, int* pathCount, const int maxPath);
 
 
    NAVMESH_API dtStatus findPolysAroundCircle(dtPolyRef startRef, const dtReal* centerPos, const dtReal radius,
                                   const dtQueryFilter* filter,
                                   dtPolyRef* resultRef, dtPolyRef* resultParent, dtReal* resultCost,
                                   int* resultCount, const int maxResult) const;
    
    NAVMESH_API dtStatus findPolysAroundShape(dtPolyRef startRef, const dtReal* verts, const int nverts,
                                  const dtQueryFilter* filter,
                                  dtPolyRef* resultRef, dtPolyRef* resultParent, dtReal* resultCost,
                                  int* resultCount, const int maxResult) const;
    
    //@UE BEGIN
    NAVMESH_API dtStatus findPolysInPathDistance(dtPolyRef startRef, const dtReal* centerPos, const dtReal pathDistance,
                                    const dtQueryFilter* filter, dtPolyRef* resultRef,
                                    int* resultCount, const int maxResult) const;
 
 
    NAVMESH_API dtStatus findNearestPoly(const dtReal* center, const dtReal* extents,
                             const dtQueryFilter* filter,
                             dtPolyRef* nearestRef, dtReal* nearestPt, const dtReal* referencePt = 0) const;
 
    NAVMESH_API dtStatus findNearestPoly2D(const dtReal* center, const dtReal* extents,
                            const dtQueryFilter* filter,
                            dtPolyRef* outProjectedRef, dtReal* outProjectedPt,
                            const dtReal* referencePt = 0, dtReal tolerance = 0) const;
 
    NAVMESH_API dtStatus findNearestContainingPoly(const dtReal* center, const dtReal* extents,
                                       const dtQueryFilter* filter,
                                       dtPolyRef* nearestRef, dtReal* nearestPt) const;
    //@UE END
 
    NAVMESH_API dtStatus queryPolygons(const dtReal* center, const dtReal* extents,
                           const dtQueryFilter* filter,
                           dtPolyRef* polys, int* polyCount, const int maxPolys) const;
 
    NAVMESH_API dtStatus findLocalNeighbourhood(dtPolyRef startRef, const dtReal* centerPos, const dtReal radius,
                                    const dtQueryFilter* filter,
                                    dtPolyRef* resultRef, dtPolyRef* resultParent,
                                    int* resultCount, const int maxResult) const;
 
    NAVMESH_API dtStatus findWallsInNeighbourhood(dtPolyRef startRef, const dtReal* centerPos, const dtReal radius,
                                      const dtQueryFilter* filter, 
                                      dtPolyRef* neiRefs, int* neiCount, const int maxNei,
                                      dtReal* resultWalls, dtPolyRef* resultRefs, int* resultCount, const int maxResult) const;
 
 
    NAVMESH_API dtStatus findWallsOverlappingShape(dtPolyRef startRef, const dtReal* verts, const int nverts,
                                       const dtQueryFilter* filter, 
                                       dtPolyRef* neiRefs, int* neiCount, const int maxNei,
                                       dtReal* resultWalls, dtPolyRef* resultRefs, int* resultCount, const int maxResult) const;
 
    NAVMESH_API dtStatus findWallsAroundPath(const dtPolyRef* path, const int pathCount, const dtReal* searchAreaPoly, const int searchAreaPolyCount,
                                       const dtReal maxAreaEnterCost, const dtQueryFilter* filter,
                                       dtPolyRef* neiRefs, int* neiCount, const int maxNei,
                                       dtReal* resultWalls, dtPolyRef* resultRefs, int* resultCount, const int maxResult) const;
    
    NAVMESH_API dtStatus moveAlongSurface(dtPolyRef startRef, const dtReal* startPos, const dtReal* endPos,
                              const dtQueryFilter* filter,
                              dtReal* resultPos, dtPolyRef* visited, int* visitedCount, const int maxVisitedSize) const;
    
    NAVMESH_API dtStatus raycast(dtPolyRef startRef, const dtReal* startPos, const dtReal* endPos,
                     const dtQueryFilter* filter,
                     dtReal* t, dtReal* hitNormal, dtPolyRef* path, int* pathCount, const int maxPath) const;
    
    NAVMESH_API dtStatus findDistanceToWall(dtPolyRef startRef, const dtReal* centerPos, const dtReal maxRadius,
                                const dtQueryFilter* filter,
                                dtReal* hitDist, dtReal* hitPos, dtReal* hitNormal) const;
    
    NAVMESH_API dtStatus getPolyWallSegments(dtPolyRef ref, const dtQueryFilter* filter,
                                 dtReal* segmentVerts, dtPolyRef* segmentRefs, int* segmentCount,
                                 const int maxSegments) const;
 
    NAVMESH_API dtStatus findRandomPoint(const dtQueryFilter* filter, float(*frand)(),
                             dtPolyRef* randomRef, dtReal* randomPt) const;
 
    NAVMESH_API dtStatus findRandomPointAroundCircle(dtPolyRef startRef, const dtReal* centerPos, const dtReal maxRadius,
                                         const dtQueryFilter* filter, float(*frand)(),
                                         dtPolyRef* randomRef, dtReal* randomPt) const;
 
    NAVMESH_API dtStatus findRandomPointInPoly(dtPolyRef ref, float(*frand)(), dtReal* randomPt) const;
 
    //@UE BEGIN
#if WITH_NAVMESH_CLUSTER_LINKS
    NAVMESH_API dtStatus testClusterPath(dtPolyRef startRef, dtPolyRef endRef) const; 
 
    NAVMESH_API dtStatus findRandomPointInCluster(dtClusterRef clusterRef, float(*frand)(),
                                      dtPolyRef* randomRef, dtReal* randomPt) const;
 
    NAVMESH_API dtStatus getPolyCluster(dtPolyRef polyRef, dtClusterRef& clusterRef) const;
#endif // WITH_NAVMESH_CLUSTER_LINKS
//@UE END
    
    NAVMESH_API dtStatus closestPointOnPoly(dtPolyRef ref, const dtReal* pos, dtReal* closest) const;
    
    NAVMESH_API dtStatus closestPointOnPolyBoundary(dtPolyRef ref, const dtReal* pos, dtReal* closest) const;
 
    NAVMESH_API dtStatus projectedPointOnPoly(dtPolyRef ref, const dtReal* pos, dtReal* projected) const;
    
    NAVMESH_API dtStatus isPointInsidePoly(dtPolyRef ref, const dtReal* pos, bool& result) const;
 
    NAVMESH_API dtStatus getPolyHeight(dtPolyRef ref, const dtReal* pos, dtReal* height) const;
 
 
    NAVMESH_API bool isValidPolyRef(dtPolyRef ref, const dtQueryFilter* filter) const;
 
    NAVMESH_API bool isInClosedList(dtPolyRef ref) const;
    
    NAVMESH_API bool wasClusterLinkSearched(dtPolyRef cFrom, dtPolyRef cTo) const;
 
    class dtNodePool* getNodePool() const { return m_nodePool; }
    
    const dtNavMesh* getAttachedNavMesh() const { return m_nav; }
 
    void getCurrentBestResult(struct dtNode*& bestNode, dtReal& bestCost) const { bestNode = m_query.lastBestNode; bestCost = m_query.lastBestNodeCost; }
 
    int getQueryNodes() const { return m_queryNodes; }
    
private:
    
    NAVMESH_API dtMeshTile* getNeighbourTileAt(int x, int y, int side) const;
 
    NAVMESH_API int queryPolygonsInTile(const dtMeshTile* tile, const dtReal* qmin, const dtReal* qmax, const dtQueryFilter* filter,
                            dtPolyRef* polys, const int maxPolys) const;
    NAVMESH_API dtPolyRef findNearestPolyInTile(const dtMeshTile* tile, const dtReal* center, const dtReal* extents,
                                    const dtQueryFilter* filter, dtReal* nearestPt) const;
    NAVMESH_API void closestPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const dtReal* pos, dtReal* closest) const;
 
    NAVMESH_API dtStatus projectedPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const dtReal* pos, dtReal* projected) const;
    
    //@UE BEGIN
    static void dtApplyEpsilon(dtReal* extents);
    
    // exposing function to be able to generate navigation corridors as sequence of point pairs
public:
    NAVMESH_API dtStatus getPortalPoints(dtPolyRef from, dtPolyRef to, dtReal* left, dtReal* right,
                             unsigned char& fromType, unsigned char& toType) const;
    NAVMESH_API dtStatus getPortalPoints(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile,
                             dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile,
                             dtReal* left, dtReal* right) const;
    
    NAVMESH_API dtStatus getEdgeMidPoint(dtPolyRef from, dtPolyRef to, dtReal* mid) const;
    NAVMESH_API dtStatus getEdgeMidPoint(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile,
                             dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile,
                             dtReal* mid) const;
    //@UE END
 
    // Appends vertex to a straight path
    NAVMESH_API dtStatus appendVertex(const dtReal* pos, const unsigned char flags, const dtPolyRef ref,
                          dtQueryResult& result, const bool bOverrideIdenticalPosition = true) const;
 
    // Appends intermediate portal points to a straight path.
    NAVMESH_API dtStatus appendPortals(const int startIdx, const int endIdx, const dtReal* endPos, const dtPolyRef* path,
                           dtQueryResult& result, const int options) const;
    
    inline bool passLinkFilterByRef(const dtMeshTile* tile, const dtPolyRef ref) const
    {
        return passLinkFilter(tile, m_nav->decodePolyIdPoly(ref));
    }
 
    inline bool passLinkFilter(const dtMeshTile* tile, const int polyIdx) const
    {
        const int linkIdx = polyIdx - tile->header->offMeshBase;
 
        return !(m_linkFilter && polyIdx >= tile->header->offMeshBase
            && linkIdx < tile->header->offMeshConCount
            && tile->offMeshCons[linkIdx].userId != 0
            && m_linkFilter->isLinkAllowed(tile->offMeshCons[linkIdx].userId) == false);
    }
 
    //@UE BEGIN
    inline void setRequireNavigableEndLocation(const bool value) { m_query.requireNavigableEndLocation = value; }
    inline bool isRequiringNavigableEndLocation() const { return m_query.requireNavigableEndLocation; }
    //@UE END
 
private:
    const dtNavMesh* m_nav;                         
    dtQuerySpecialLinkFilter* m_linkFilter;         
 
    struct dtQueryData
    {
        dtStatus status;
        struct dtNode* lastBestNode;
        dtReal lastBestNodeCost;
        dtPolyRef startRef, endRef;
        dtReal startPos[3], endPos[3];
        dtReal costLimit;                   //@UE ///< Cost limit of nodes allowed to be added to the open list
        const dtQueryFilter* filter;
        unsigned char requireNavigableEndLocation : 1;  //@UE
    };
    dtQueryData m_query;                
 
    class dtNodePool* m_tinyNodePool;   
    class dtNodePool* m_nodePool;       
    class dtNodeQueue* m_openList;      
 
    mutable int m_queryNodes;
};
 
NAVMESH_API dtNavMeshQuery* dtAllocNavMeshQuery();
 
NAVMESH_API void dtFreeNavMeshQuery(dtNavMeshQuery* query);
 
#endif // DETOURNAVMESHQUERY_H