channelsectionptr.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/channel/channelarray.h"
#include "gwnavruntime/kernel/SF_RefCount.h"


namespace Kaim
{

class PositionOnPath;

class ChannelSectionPtr
{
public:

    ChannelSectionPtr();
    ChannelSectionPtr(Ptr<ChannelArray> channelArray, KyUInt32 channelIdx, KyUInt32 sectionIdx);
    ~ChannelSectionPtr();

    void Invalidate();

    KyResult Set(Ptr<ChannelArray> channelArray, KyUInt32 channelIdx, KyUInt32 sectionIdx);

    KyResult SetFromPositionOnPath(const PositionOnPath& positionOnPath);

    KyResult Update(const Vec3f& prevPos, const Vec3f& newPos);

    KyResult Update(const PositionOnPath& positionOnPath, const Vec3f& newPos);

    bool IsValid() const;

    bool operator==(const ChannelSectionPtr& other) const;
    bool operator!=(const ChannelSectionPtr& other) const;


    bool IsFirstSection() const;

    bool IsLastSection() const;

    bool IsTriangularLeftTurn() const;

    bool IsTriangularRightTurn() const;

    bool IsPositionInSection(const Vec2f& position, KyUInt32& positionFlags) const;

    ChannelArray* GetChannelArray() const;
    KyUInt32      GetChannelIdx()   const;
    KyUInt32      GetSectionIdx()   const;

    const Channel* GetChannel() const; // WARNING : This object must be valid !

    KyUInt32 GetPathNodeIdxOfSectionStartGate() const;
    KyUInt32 GetPathNodeIdxOfSectionEndGate()   const;
    KyUInt32 GetPathNodeIdxOfChannelLastGate()  const;

    KyUInt32    GetSectionStartGateIdx() const;
    KyUInt32    GetSectionEndGateIdx()   const;
    const Gate& GetSectionStartGate()    const;
    const Gate& GetSectionEndGate()      const;

public: // internal
    // Beware this set the channel section based on node index and doesn't take care of node position
    // i.e. Node position could be in the adjacent section
    KyResult SetFromPathNodeIdx(const Ptr<ChannelArray>& channelArray, KyUInt32 pathNodeIdx);

public: // internal
    Ptr<ChannelArray> m_channelArray;
    KyUInt32  m_channelIdx;  // The index of the Channel in the ChannelArray.
    KyUInt32  m_sectionIdx;     // The index of the section, i.e. the Gate starting the quad or triangle this position stays on.
};


KY_INLINE bool ChannelSectionPtr::IsValid() const
{
    if (m_channelArray != nullptr && m_channelIdx < m_channelArray->GetChannelCount())
    {
        const Channel* channel = m_channelArray->GetChannel(m_channelIdx);
        return channel != nullptr && m_sectionIdx < channel->GetGateCount() + 1;
    }

    return false;
}

KY_INLINE bool ChannelSectionPtr::IsFirstSection() const { return m_sectionIdx == 0;                            }
KY_INLINE bool ChannelSectionPtr::IsLastSection()  const { return m_sectionIdx == GetChannel()->GetGateCount(); }

KY_INLINE bool ChannelSectionPtr::IsTriangularRightTurn() const
{
    GateType type = GetSectionStartGate().m_type;
    return (type == RightTurnStart) || (type == RightTurnIntermediary);
}

KY_INLINE bool ChannelSectionPtr::IsTriangularLeftTurn() const
{
    GateType type = GetSectionStartGate().m_type;
    return (type == LeftTurnStart) || (type == LeftTurnIntermediary);
}

KY_INLINE bool ChannelSectionPtr::IsPositionInSection(const Vec2f& position, KyUInt32& positionFlags) const
{
    return GetChannel()->IsPositionInSection(position, m_sectionIdx, positionFlags);
}

KY_INLINE ChannelArray*  ChannelSectionPtr::GetChannelArray()                  const { return m_channelArray;                                                      }
KY_INLINE KyUInt32       ChannelSectionPtr::GetChannelIdx()                    const { return m_channelIdx;                                                        }
KY_INLINE KyUInt32       ChannelSectionPtr::GetSectionIdx()                    const { return m_sectionIdx;                                                        }
KY_INLINE const Channel* ChannelSectionPtr::GetChannel()                       const { return m_channelArray->GetChannel(m_channelIdx);                            }

KY_INLINE KyUInt32       ChannelSectionPtr::GetPathNodeIdxOfSectionStartGate() const { return GetChannel()->GetGatePathNodeIdx(GetSectionStartGateIdx());          }
KY_INLINE KyUInt32       ChannelSectionPtr::GetPathNodeIdxOfSectionEndGate()   const { return GetChannel()->GetGatePathNodeIdx(GetSectionEndGateIdx());            }
KY_INLINE KyUInt32       ChannelSectionPtr::GetPathNodeIdxOfChannelLastGate()  const { return GetChannel()->GetGatePathNodeIdx(GetChannel()->GetGateCount() -1);   }

KY_INLINE KyUInt32       ChannelSectionPtr::GetSectionStartGateIdx()           const { return GetChannel()->GetSectionStartGateIdx(m_sectionIdx);                  }
KY_INLINE KyUInt32       ChannelSectionPtr::GetSectionEndGateIdx()             const { return GetChannel()->GetSectionEndGateIdx(m_sectionIdx);                    }
KY_INLINE const Gate&    ChannelSectionPtr::GetSectionStartGate()              const { return GetChannel()->GetSectionStartGate(m_sectionIdx);                     }
KY_INLINE const Gate&    ChannelSectionPtr::GetSectionEndGate()                const { return GetChannel()->GetSectionEndGate(m_sectionIdx);                       }

KY_INLINE bool ChannelSectionPtr::operator!=(const ChannelSectionPtr& other) const { return !(*this==other); }
KY_INLINE bool ChannelSectionPtr::operator==(const ChannelSectionPtr& other) const
{
    return m_channelArray == other.m_channelArray && m_channelIdx == other.m_channelIdx && m_sectionIdx == other.m_sectionIdx;
}

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const ChannelSectionPtr& channelSectionPtr)
{
    os << "{" << channelSectionPtr.m_channelIdx << ", " << channelSectionPtr.m_sectionIdx << "}";
    return os;
}

} // namespace Kaim