patheventlist.h

Go to the documentation of this file.

/*
* Copyright 2016 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.
*/


#pragma once

#include "gwnavruntime/path/positiononpath.h"
#include "gwnavruntime/containers/bitfield.h"
#include "gwnavruntime/database/navtagptr.h"
#include "gwnavruntime/containers/sharedpoollist.h"


namespace Kaim
{

enum PathEventType
{
    PathEventType_Undefined              , 
    PathEventType_NavGraphVertex         , 
    PathEventType_NavTagSwitch           , 
    PathEventType_OutsideToNavMeshSwitch , 
    PathEventType_NavMeshToOutsideSwitch , 
    PathEventType_OutsideNavDataPathNode , 

    PathEventType_OnNavMeshPathNode,

    PathEventType_OnNavMeshAfterCollision
};

enum PathEventStatusInList
{
    PathEventStatus_Undefined,          
    PathEventStatus_WithinBounds,       
    PathEventStatus_LowerBound,         
    PathEventStatus_UpperBound,         
    PathEventStatus_TemporaryUpperBound 
};

enum CheckPointStatus
{
    CheckPointStatus_EventIsNotACheckPoint,              
    CheckPointStatus_EventIsACheckPoint,                 
};


class PathEvent
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Path)
public:
    // ------------------------------ Functions -----------------------------

    PathEvent()
        : m_eventType(PathEventType_Undefined)
        , m_eventStatusInList(PathEventStatus_Undefined)
        , m_checkPointStatus(CheckPointStatus_EventIsNotACheckPoint)
        , m_userSpecific(0)
    {}

    void  SetCheckPointStatus(CheckPointStatus checkPointStatus); 
    void  SetCheckPointWithDirection(Vec2f direction); 
    bool  IsACheckPoint()  const; 
    bool  IsACheckPointWithDirection() const; 
    const Vec2f& GetCheckPointDirection() const; 

    bool IsOnUpperBound() const;
    bool IsOnLowerBound() const;

    bool IsAtLastNodeOfPath() const;
    bool IsAtLastNodeOfAChannel() const;
    Path* GetPath() const;

public: // internal
    // ---------------------------------- Public Data Members ----------------------------------

    PositionOnPath m_positionOnPath;
    PathEventType m_eventType;
    PathEventStatusInList m_eventStatusInList;
    CheckPointStatus m_checkPointStatus;
    Vec2f m_checkPointDirection;

    KyUInt32 m_userSpecific;
};


class PathEventInterval
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Path)
public:
    // ------------------------------ Functions -----------------------------

    PathEventInterval() {}


    // ---------------------------------- Public Data Members ----------------------------------

    PathEvent m_endingEventOnPath;
    NavTagPtr m_navTagOnInterval;
};


class PathEventList
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Bot)
    KY_CLASS_WITHOUT_COPY(PathEventList)

public:
    // ------------------------------ Functions -----------------------------

    PathEventList();
    ~PathEventList();

    void Clear();

    KyUInt32 GetPathEventCount()        const;
    KyUInt32 GetPathEventIntervalCount() const;

    PathEvent& GetPathEvent(KyUInt32 eventIdx);
    PathEvent& GetFirstPathEvent();
    PathEvent& GetLastPathEvent();

    const PathEvent& GetPathEvent(KyUInt32 eventIdx) const;
    const PathEvent& GetFirstPathEvent() const;
    const PathEvent& GetLastPathEvent() const;

    KyUInt32 GetIntervalIdxBeforeEvent(KyUInt32 eventIdx) const;

    KyUInt32 GetIntervalIdxAfterEvent(KyUInt32 eventIdx) const;

    const NavTag* GetNavTagOnIntervalBeforeEvent(KyUInt32 eventIdx) const;

    const NavTag* GetNavTagOnIntervalAfterEvent(KyUInt32 eventIdx) const;

    KyUInt32 GetStartPathEventIdxOfInterval(KyUInt32 intervalIdx) const;
    KyUInt32 GetEndPathEventIdxOfInterval(KyUInt32 intervalIdx)   const;

    const PathEvent& GetStartPathEventOfInterval(KyUInt32 intervalIdx) const;
    const PathEvent& GetEndPathEventOfInterval(KyUInt32 intervalIdx)   const;

    const NavTag* GetNavTagOfEventInterval(KyUInt32 intervalIdx) const;


public: // internal

    // the first interval is a dummy one used to store the first event.
    // all the other PathEventInterval store the PathEvent at the end of the interval +
    // a NavTagPtr from which the NavTag along the interval can be retrieved
    KyArray<PathEventInterval, MemStat_Bot> m_pathEventIntervalArray;
};

KY_INLINE void PathEvent::SetCheckPointStatus(CheckPointStatus checkPointStatus) { m_checkPointStatus = checkPointStatus; m_checkPointDirection = Vec2f::Zero(); }
KY_INLINE void PathEvent::SetCheckPointWithDirection(Vec2f direction) { m_checkPointStatus = CheckPointStatus_EventIsACheckPoint; m_checkPointDirection = direction; }
KY_INLINE bool PathEvent::IsACheckPoint() const  { return m_checkPointStatus == CheckPointStatus_EventIsACheckPoint; }
KY_INLINE bool PathEvent::IsACheckPointWithDirection() const  { return IsACheckPoint() == true && m_checkPointDirection != Vec2f::Zero(); }
KY_INLINE const Vec2f& PathEvent::GetCheckPointDirection() const { return m_checkPointDirection; }

KY_INLINE bool PathEvent::IsOnUpperBound() const { return m_eventStatusInList == PathEventStatus_UpperBound || m_eventStatusInList == PathEventStatus_TemporaryUpperBound; }
KY_INLINE bool PathEvent::IsOnLowerBound() const { return m_eventStatusInList == PathEventStatus_LowerBound; }

KY_INLINE bool PathEvent::IsAtLastNodeOfPath()     const { return m_positionOnPath.IsAtLastNodeOfPath();     }
KY_INLINE bool PathEvent::IsAtLastNodeOfAChannel() const { return m_positionOnPath.IsAtLastNodeOfAChannel(); }

KY_INLINE Path* PathEvent::GetPath() const { return m_positionOnPath.GetPath(); }

KY_INLINE PathEventList::PathEventList() {}
KY_INLINE PathEventList::~PathEventList() { Clear(); }

KY_INLINE void PathEventList::Clear() {  m_pathEventIntervalArray.Clear(); }

KY_INLINE KyUInt32 PathEventList::GetPathEventCount() const { return m_pathEventIntervalArray.GetCount(); }

KY_INLINE KyUInt32 PathEventList::GetPathEventIntervalCount() const
{
    if (m_pathEventIntervalArray.GetCount() != 0)
        return m_pathEventIntervalArray.GetCount() - 1;

    return 0;
}

KY_INLINE KyUInt32 PathEventList::GetIntervalIdxBeforeEvent(KyUInt32 eventIdx) const
{
    KY_LOG_ERROR_IF(eventIdx >= GetPathEventCount(), ("Input index is not a valid event index"));
    KY_LOG_ERROR_IF(eventIdx == 0, ("You cannot retrieve the index of the interval before the first event. It will return unused index"));
    return eventIdx - 1;
}

KY_INLINE KyUInt32 PathEventList::GetIntervalIdxAfterEvent(KyUInt32 eventIdx) const
{
    KY_LOG_ERROR_IF(eventIdx >= GetPathEventCount(), ("Input index is not a valid event index"));
    KY_LOG_ERROR_IF(eventIdx == GetPathEventCount() - 1, ("You cannot retrieve the index of the interval after the last event. It will return unused index"));
    return eventIdx;
}

KY_INLINE const NavTag* PathEventList::GetNavTagOnIntervalBeforeEvent(KyUInt32 eventIdx) const
{
    return GetNavTagOfEventInterval(GetIntervalIdxBeforeEvent(eventIdx));
}
KY_INLINE const NavTag* PathEventList::GetNavTagOnIntervalAfterEvent(KyUInt32 eventIdx) const
{
    return GetNavTagOfEventInterval(GetIntervalIdxAfterEvent(eventIdx));
}

KY_INLINE const NavTag* PathEventList::GetNavTagOfEventInterval(KyUInt32 intervalIdx) const
{
    KY_LOG_ERROR_IF(intervalIdx >= GetPathEventIntervalCount(), ("Input index is not a valid interval index"));
    return m_pathEventIntervalArray[intervalIdx + 1].m_navTagOnInterval.GetNavTag();
}

KY_INLINE KyUInt32 PathEventList::GetStartPathEventIdxOfInterval(KyUInt32 intervalIdx) const
{
    KY_LOG_ERROR_IF(intervalIdx >= GetPathEventIntervalCount(), ("Input index is not a valid interval index"));
    return intervalIdx;
}
KY_INLINE KyUInt32 PathEventList::GetEndPathEventIdxOfInterval(KyUInt32 intervalIdx) const
{
    KY_LOG_ERROR_IF(intervalIdx >= GetPathEventIntervalCount(), ("Input index is not a valid interval index"));
    return intervalIdx + 1;
}

KY_INLINE const PathEvent& PathEventList::GetStartPathEventOfInterval(KyUInt32 intervalIdx) const
{
    KY_DEBUG_ASSERTN(intervalIdx < GetPathEventIntervalCount(), ("Input index is not a valid interval index"));
    return m_pathEventIntervalArray[intervalIdx].m_endingEventOnPath;
}
KY_INLINE const PathEvent& PathEventList::GetEndPathEventOfInterval(KyUInt32 intervalIdx) const
{
    KY_DEBUG_ASSERTN(intervalIdx < GetPathEventIntervalCount(), ("Input index is not a valid interval index"));
    return m_pathEventIntervalArray[intervalIdx + 1].m_endingEventOnPath;
}

KY_INLINE PathEvent& PathEventList::GetPathEvent(KyUInt32 eventIdx)
{
    KY_DEBUG_ASSERTN(eventIdx < GetPathEventCount(), ("Input index is not a valid event index"));
    return m_pathEventIntervalArray[eventIdx].m_endingEventOnPath;
}

KY_INLINE PathEvent& PathEventList::GetFirstPathEvent() { return GetPathEvent(0); }
KY_INLINE PathEvent& PathEventList::GetLastPathEvent() { return GetPathEvent(GetPathEventCount() - 1); }

KY_INLINE const PathEvent& PathEventList::GetPathEvent(KyUInt32 eventIdx) const
{
    KY_DEBUG_ASSERTN(eventIdx < GetPathEventCount(), ("Input index is not a valid event index"));
    return m_pathEventIntervalArray[eventIdx].m_endingEventOnPath;
}

KY_INLINE const PathEvent& PathEventList::GetFirstPathEvent() const { return GetPathEvent(0); }
KY_INLINE const PathEvent& PathEventList::GetLastPathEvent() const { return GetPathEvent(GetPathEventCount() - 1); }


} // namespace Kaim