baseastarquery.h

Go to the documentation of this file.

/*
* Copyright 2015 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/


// Primary contact: JUBA - secondary contact: NOBODY
#ifndef Navigation_BaseAStarQuery_H
#define Navigation_BaseAStarQuery_H

#include "gwnavruntime/queries/ipathfinderquery.h"
#include "gwnavruntime/navmesh/identifiers/navtriangleptr.h"
#include "gwnavruntime/querysystem/workingmemcontainers/navdatachangeindexingrid.h"
#include "gwnavruntime/queries/utils/pathfinderqueryutils.h"
#include "gwnavruntime/queries/utils/pathrefinercontext.h"
#include "gwnavruntime/queries/utils/pathclampercontext.h"
#include "gwnavruntime/queries/utils/traversalparams.h"
#include "gwnavruntime/queries/utils/pathrefinerconfig.h"
#include "gwnavruntime/queries/utils/cellfilter.h"


namespace Kaim
{

class Path;

enum AStarQueryResult
{
    ASTAR_NOT_INITIALIZED = QUERY_NOT_INITIALIZED, 
    ASTAR_NOT_PROCESSED   = QUERY_NOT_PROCESSED  , 

    ASTAR_PROCESSING_TRAVERSAL                   , 
    ASTAR_PROCESSING_TRAVERSAL_DONE              , 
    ASTAR_PROCESSING_ABSTRACT_PATH               , 
    ASTAR_PROCESSING_REFINING_INIT               , 
    ASTAR_PROCESSING_REFINING_RESETCOST          , 
    ASTAR_PROCESSING_REFINING                    , 
    ASTAR_PROCESSING_PATHCLAMPING_INIT           , 
    ASTAR_PROCESSING_PATHCLAMPING                , 
    ASTAR_PROCESSING_PATHBUILDING                , 
    ASTAR_PROCESSING_CHANNEL_INIT                , 
    ASTAR_PROCESSING_CHANNEL_COMPUTE             , 

    ASTAR_DONE_START_OUTSIDE                     , 
    ASTAR_DONE_START_NAVTAG_FORBIDDEN            , 
    ASTAR_DONE_END_OUTSIDE                       , 
    ASTAR_DONE_END_NAVTAG_FORBIDDEN              , 
    ASTAR_DONE_PATH_NOT_FOUND                    , 
    ASTAR_DONE_NAVDATA_CHANGED                   , 
    ASTAR_DONE_ERROR_LACK_OF_WORKING_MEMORY      , 
    ASTAR_DONE_COMPUTATION_ERROR                 , 
    ASTAR_DONE_CHANNELCONFIG_ERROR               , 
    ASTAR_DONE_CHANNELCOMPUTATION_ERROR          , 
    ASTAR_DONE_COMPUTATION_CANCELED              , 

    ASTAR_DONE_DEST_IS_START_NO_PATH             , 
    ASTAR_DONE_PATH_FOUND                          
};

enum AStarQueryTryCanGoMode
{
    ASTAR_DO_NOT_TRY_RAYCANGO = 0,
    ASTAR_DO_TRY_RAYCANGO     = 1
};

class BaseAStarQuery : public IPathFinderQuery
{
public:
    static  QueryType            GetStaticType() { return TypeAStar; }
    virtual QueryType            GetType() const { return TypeAStar; }
    virtual void                 BuildQueryBlob(BaseBlobHandler* blobHandler);
    virtual void                 InitFromQueryBlob(World* world, void* blob);
    virtual Ptr<BaseBlobHandler> CreateQueryBlobHandler() { return CreateStaticQueryBlobHandler(); }
    static Ptr<BaseBlobHandler>  CreateStaticQueryBlobHandler();

    // ---------------------------------- Main API functions ----------------------------------

    virtual void             GetPathFinderTextResult(String&)                         const;
    virtual void             DisplayPropagationBounds(ScopedDisplayList& displayList) const;
    virtual PathFinderResult GetPathFinderResult()                                    const;
    virtual const Vec3f*     GetDestination()                                         const;

    AStarQueryResult                     GetResult()                        const;
    KyFloat32                            GetFromOutsideNavMeshDistance()    const;
    KyFloat32                            GetToOutsideNavMeshDistance()      const;
    KyFloat32                            GetPropagationBoxExtent()          const;
    const Vec3f&                         GetStartPos()                      const;
    const Vec3f&                         GetDestPos()                       const;
    const NavTrianglePtr&                GetStartTrianglePtr()              const;
    const NavGraphEdgePtr&               GetStartNavGraphEdgePtr()          const;
    const NavGraphVertexPtr&             GetStartNavGraphVertexPtr()        const;
    const NavTrianglePtr&                GetDestTrianglePtr()               const;
    const NavGraphEdgePtr&               GetDestNavGraphEdgePtr()           const;
    const NavGraphVertexPtr&             GetDestNavGraphVertexPtr()         const;
    AStarQueryTryCanGoMode               GetTryCanGoMode()                  const;
    PathFinderQueryComputeChannelMode    GetComputeChannelMode()            const;
    const ChannelComputerConfig&         GetChannelComputerConfig()         const;
    Path*                                GetPath()                          const;
    KyUInt32                             GetNumberOfProcessedNodePerFrame() const;
    Path*                                GetAbstractPath()                  const;
    PathFinderAbstractGraphTraversalMode GetAbstractGraphTraversalMode()    const;

    const PositionSpatializationRange&   GetPositionSpatializationRange() const;

    void ComputePathRefinerConfigInternals();
    const PathRefinerConfig& GetPathRefinerConfig() const;


public: // Internal
    void BindToDatabase(Database* database);
    void Initialize(const Vec3f& startPos, const Vec3f& destPos);

    void SetStartTrianglePtr(const NavTrianglePtr& startTrianglePtr);
    void SetStartNavGraphEdgePtr(const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode);
    void SetStartNavGraphVertexPtr(const NavGraphVertexPtr& startNavGraphVertexPtr);

    void SetDestTrianglePtr(const NavTrianglePtr& destTrianglePtr);
    void SetDestNavGraphEdgePtr(const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode);
    void SetDestNavGraphVertexPtr(const NavGraphVertexPtr& startNavGraphVertexPtr);

    void SetTryCanGoMode(AStarQueryTryCanGoMode tryCanGoMode);
    void SetComputeChannelMode(PathFinderQueryComputeChannelMode computeChannelMode);
    void SetChannelComputerConfig(const ChannelComputerConfig& channelComputerConfig);
    void SetPropagationBoxExtent(KyFloat32 propagationBoxExtent);
    void SetPositionSpatializationRange(const PositionSpatializationRange& positionSpatializationRange);
    void SetFromOutsideNavMeshDistance(KyFloat32 fromOutsideNavMeshDistance);
    void SetToOutsideNavMeshDistance(KyFloat32 toOutsideNavMeshDistance);
    void SetNumberOfProcessedNodePerFrame(KyUInt32 numberOfProcessedNodePerFrame);
    void SetAbstractGraphTraversalMode(PathFinderAbstractGraphTraversalMode abstractGraphTraversalMode);
    void SetPathClamperFlagMask(PathClamperFlagMask pathClamperFlagMask); // Call this method after BindToDatabase()

protected :
    BaseAStarQuery();
    virtual ~BaseAStarQuery() {}
    void SetResult(AStarQueryResult result);
    
    void InitCellFilterFromAbstractGraph();
    void ReplaceNodesOfShortestPathOnMiddleOfNavHalfEdge(WorkingMemory* workingMemory);
protected :
    // after the call to Initialize
    NavTrianglePtr m_startTrianglePtr;

    // after the call to Initialize
    NavTrianglePtr m_destTrianglePtr;


    NavGraphEdgePtr m_startNavGraphEdgePtr;
    NavGraphEdgePtr m_destNavGraphEdgePtr;

    NavGraphEdgeDirection m_navGraphEdgePathfindMode;

    NavGraphVertexPtr m_startNavGraphVertexPtr;
    NavGraphVertexPtr m_destNavGraphVertexPtr;

    Vec3f m_destPos3f;        
    Vec3f m_startInsidePos3f; 
    Vec3f m_destInsidePos3f;  

    AStarQueryTryCanGoMode m_tryCanGoMode;
    TraversalParameters m_traversalParams;
    PathRefinerConfig m_pathRefinerConfig;
    PathClamperFlagMask m_pathClamperFlagMask; // Control PathClamper options

    KyFloat32 m_propagationBoxExtent; 
    Ptr<CellFilter> m_propagationCellFilter;

    Ptr<Path> m_abstractPath;                 

    AStarQueryResult m_result; 
};


KY_INLINE void BaseAStarQuery::SetResult(AStarQueryResult result)                               { m_result                = result;               }
KY_INLINE void BaseAStarQuery::SetTryCanGoMode(AStarQueryTryCanGoMode tryCanGoMode)             { m_tryCanGoMode          = tryCanGoMode;         }
KY_INLINE void BaseAStarQuery::SetComputeChannelMode(PathFinderQueryComputeChannelMode mode)    { m_computeChannelMode    = mode;                 }
KY_INLINE void BaseAStarQuery::SetChannelComputerConfig(const ChannelComputerConfig& config)    { m_channelComputerConfig = config;               }
KY_INLINE void BaseAStarQuery::SetPropagationBoxExtent(KyFloat32 propagationBoxExtent)          { m_propagationBoxExtent  = propagationBoxExtent; }

KY_INLINE void BaseAStarQuery::SetStartTrianglePtr(const NavTrianglePtr& startTrianglePtr)
{
    m_startTrianglePtr = startTrianglePtr;
    KY_LOG_WARNING_IF(m_startNavGraphEdgePtr.IsValid(), ("You are setting a start NavTrianglePtr whereas a start NavGraphEdgePtr was set too."));
    KY_LOG_WARNING_IF(m_startNavGraphVertexPtr.IsValid(), ("You are setting a start NavTrianglePtr whereas a start NavGraphVertexPtr was set too."));
    m_startNavGraphEdgePtr.Invalidate();
    m_startNavGraphVertexPtr.Invalidate();
}

KY_INLINE void BaseAStarQuery::SetStartNavGraphEdgePtr(const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode)
{
    m_startNavGraphEdgePtr     = startNavGraphEdgePtr; 
    m_navGraphEdgePathfindMode = navGraphEdgePathfindMode;
    KY_LOG_WARNING_IF(m_startTrianglePtr.IsValid(), ("You are setting a start NavGraphEdgePtr whereas a start NavTrianglePtr was set too."));
    KY_LOG_WARNING_IF(m_startNavGraphVertexPtr.IsValid(), ("You are setting a start NavGraphEdgePtr whereas a start NavGraphVertexPtr was set too."));
    m_startTrianglePtr.Invalidate();
    m_startNavGraphVertexPtr.Invalidate();
}

KY_INLINE void BaseAStarQuery::SetStartNavGraphVertexPtr(const NavGraphVertexPtr& startNavGraphVertexPtr)
{
    m_startNavGraphVertexPtr = startNavGraphVertexPtr; 
    KY_LOG_WARNING_IF(m_startTrianglePtr.IsValid(), ("You are setting a start NavGraphVertexPtr whereas a start NavTrianglePtr was set too."));
    KY_LOG_WARNING_IF(m_startNavGraphEdgePtr.IsValid(), ("You are setting a start NavGraphVertexPtr whereas a start NavGraphEdgePtr was set too."));
    m_startTrianglePtr.Invalidate();
    m_startNavGraphEdgePtr.Invalidate();
}

KY_INLINE void BaseAStarQuery::SetDestTrianglePtr(const NavTrianglePtr& destTrianglePtr)
{ 
    m_destTrianglePtr  = destTrianglePtr;
    KY_LOG_WARNING_IF(m_destNavGraphEdgePtr.IsValid(), ("You are setting a dest NavTrianglePtr whereas a dest NavGraphEdgePtr was set too."));
    KY_LOG_WARNING_IF(m_destNavGraphVertexPtr.IsValid(), ("You are setting a dest NavTrianglePtr whereas a dest NavGraphVertexPtr was set too."));
    m_destNavGraphEdgePtr.Invalidate();
    m_destNavGraphVertexPtr.Invalidate();
}

KY_INLINE void BaseAStarQuery::SetDestNavGraphEdgePtr(const NavGraphEdgePtr& destNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode)     
{ 
    m_destNavGraphEdgePtr      = destNavGraphEdgePtr; 
    m_navGraphEdgePathfindMode = navGraphEdgePathfindMode;
    KY_LOG_WARNING_IF(m_destTrianglePtr.IsValid(), ("You are setting a dest NavGraphEdgePtr whereas a dest NavTrianglePtr was set too."));
    KY_LOG_WARNING_IF(m_destNavGraphVertexPtr.IsValid(), ("You are setting a dest NavGraphEdgePtr whereas a dest NavGraphVertexPtr was set too."));
    m_destTrianglePtr.Invalidate();
    m_destNavGraphVertexPtr.Invalidate();
}

KY_INLINE void BaseAStarQuery::SetDestNavGraphVertexPtr(const NavGraphVertexPtr& destNavGraphVertexPtr) 
{ 
    m_destNavGraphVertexPtr = destNavGraphVertexPtr; 
    KY_LOG_WARNING_IF(m_destTrianglePtr.IsValid(), ("You are setting a dest NavGraphVertexPtr whereas a dest NavTrianglePtr was set too."));
    KY_LOG_WARNING_IF(m_destNavGraphEdgePtr.IsValid(), ("You are setting a dest NavGraphVertexPtr whereas a dest NavGraphEdgePtr was set too."));
    m_destTrianglePtr.Invalidate();
    m_destNavGraphEdgePtr.Invalidate();
}

KY_INLINE AStarQueryResult                  BaseAStarQuery::GetResult()                 const { return m_result;                 }
KY_INLINE const Vec3f&                      BaseAStarQuery::GetDestPos()                const { return m_destPos3f;              }
KY_INLINE const NavTrianglePtr&             BaseAStarQuery::GetStartTrianglePtr()       const { return m_startTrianglePtr;       }
KY_INLINE const NavGraphEdgePtr&            BaseAStarQuery::GetStartNavGraphEdgePtr()   const { return m_startNavGraphEdgePtr;   }
KY_INLINE const NavGraphVertexPtr&          BaseAStarQuery::GetStartNavGraphVertexPtr() const { return m_startNavGraphVertexPtr; }
KY_INLINE const NavTrianglePtr&             BaseAStarQuery::GetDestTrianglePtr()        const { return m_destTrianglePtr;        }
KY_INLINE const NavGraphEdgePtr&            BaseAStarQuery::GetDestNavGraphEdgePtr()    const { return m_destNavGraphEdgePtr;    }
KY_INLINE const NavGraphVertexPtr&          BaseAStarQuery::GetDestNavGraphVertexPtr()  const { return m_destNavGraphVertexPtr;  }
KY_INLINE Path*                             BaseAStarQuery::GetPath()                   const { return m_path;                   }
KY_INLINE Path*                             BaseAStarQuery::GetAbstractPath()           const { return m_abstractPath;           }
KY_INLINE AStarQueryTryCanGoMode            BaseAStarQuery::GetTryCanGoMode()           const { return m_tryCanGoMode;           }
KY_INLINE PathFinderQueryComputeChannelMode BaseAStarQuery::GetComputeChannelMode()     const { return m_computeChannelMode;     }
KY_INLINE const ChannelComputerConfig&      BaseAStarQuery::GetChannelComputerConfig()  const { return m_channelComputerConfig;  }
KY_INLINE const Vec3f*                      BaseAStarQuery::GetDestination()            const { return &GetDestPos();            }
KY_INLINE KyFloat32                         BaseAStarQuery::GetPropagationBoxExtent()   const { return m_propagationBoxExtent;   }

KY_INLINE KyFloat32    BaseAStarQuery::GetFromOutsideNavMeshDistance()    const { return m_traversalParams.GetFromOutsideNavMeshDistance();    }
KY_INLINE KyFloat32    BaseAStarQuery::GetToOutsideNavMeshDistance()      const { return m_traversalParams.GetToOutsideNavMeshDistance();      }
KY_INLINE KyUInt32     BaseAStarQuery::GetNumberOfProcessedNodePerFrame() const { return m_traversalParams.GetNumberOfProcessedNodePerFrame(); }
KY_INLINE const Vec3f& BaseAStarQuery::GetStartPos()                      const { return IPathFinderQuery::GetStartPos();                      }

KY_INLINE void BaseAStarQuery::SetFromOutsideNavMeshDistance(KyFloat32 fromOutsideNavMeshDistance)
{
    m_traversalParams.SetFromOutsideNavMeshDistance(fromOutsideNavMeshDistance);
}
KY_INLINE void BaseAStarQuery::SetToOutsideNavMeshDistance(KyFloat32 toOutsideNavMeshDistance)
{
    m_traversalParams.SetToOutsideNavMeshDistance(toOutsideNavMeshDistance);
}
KY_INLINE void BaseAStarQuery::SetNumberOfProcessedNodePerFrame(KyUInt32 numberOfProcessedNodePerFrame)
{
    m_traversalParams.SetNumberOfProcessedNodePerFrame(numberOfProcessedNodePerFrame);
}
KY_INLINE void BaseAStarQuery::SetPositionSpatializationRange(const PositionSpatializationRange& positionSpatializationRange)
{
    m_traversalParams.SetPositionSpatializationRange(positionSpatializationRange);
}

KY_INLINE void BaseAStarQuery::SetAbstractGraphTraversalMode(PathFinderAbstractGraphTraversalMode abstractGraphTraversalMode)
{
    m_traversalParams.SetAbstractGraphTraversalMode(abstractGraphTraversalMode);
}

KY_INLINE PathFinderAbstractGraphTraversalMode BaseAStarQuery::GetAbstractGraphTraversalMode() const
{
    return m_traversalParams.GetAbstractGraphTraversalMode();
}

KY_INLINE const PositionSpatializationRange& BaseAStarQuery::GetPositionSpatializationRange() const { return m_traversalParams.GetPositionSpatializationRange(); }

KY_INLINE void BaseAStarQuery::ComputePathRefinerConfigInternals()              { m_pathRefinerConfig.ComputeInternals();}
KY_INLINE const PathRefinerConfig& BaseAStarQuery::GetPathRefinerConfig() const { return m_pathRefinerConfig;}
KY_INLINE void BaseAStarQuery::SetPathClamperFlagMask(PathClamperFlagMask pathClamperFlagMask) { m_pathClamperFlagMask = pathClamperFlagMask; }
}

#endif //Navigation_BaseAstarQuery_H