channel.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.
*/

#ifndef Navigation_Channel_H
#define Navigation_Channel_H

#include "gwnavruntime/visualsystem/displaylistblob.h"
#include "gwnavruntime/kernel/SF_RefCount.h"


namespace Kaim
{

class World;
class Bubble;
class ChannelBlob;


enum GateType
{
    UndefinedGateType    =  0, 

    StartGate            =  1, 
    EndGate              =  2, 

    SmallLeftTurn        =  3, 
    LeftTurnStart        =  4, 
    LeftTurnIntermediary =  5, 
    LeftTurnEnd          =  6, 

    SmallRightTurn       =  7, 
    RightTurnStart       =  8, 
    RightTurnIntermediary=  9, 
    RightTurnEnd         = 10, 

    WidthAdjustment      = 11, 
    ClampingAdjustment   = 12, 

    GATE_TYPE_COUNT
};

KY_INLINE bool IsALeftTurnGate(GateType gateType)  { return gateType >= SmallLeftTurn  && gateType <= LeftTurnEnd;  }
KY_INLINE bool IsARightTurnGate(GateType gateType) { return gateType >= SmallRightTurn && gateType <= RightTurnEnd; }
KY_INLINE bool IsATurnGate(GateType gateType)      { return gateType >= SmallLeftTurn && gateType <= RightTurnEnd; }


enum RelativePositionToChannelSectionFlag
{
    RelativePositionToChannelSection_Inside  = 0, 

    RelativePositionToChannelSection_Before  = 1, 
    RelativePositionToChannelSection_After   = 2, 
    RelativePositionToChannelSection_OnLeft  = 4, 
    RelativePositionToChannelSection_OnRight = 8, 
};


class ChannelDisplayConfig
{
public:
    ChannelDisplayConfig() { SetDefaults(); }
    void SetDefaults();

    bool m_displayChannelIndex;
    bool m_displaySectionIndex;
    bool m_displayGateIndex;
    bool m_displayExtremityPolylines;
    bool m_displayOutline;
    bool m_displayGates;
    bool m_displayPathEdges;
    bool m_displayPathNodes;
    bool m_displayGateTypeLabel;
    bool m_displayGateTypeColor;
    bool m_displayChannelWidthLeft;
    bool m_displayChannelWidthRight;

    VisualColor m_channelIndexColor;
    VisualColor m_sectionIndexColor;
    VisualColor m_gateIndexColor;
    VisualColor m_pathColor;
    VisualColor m_leftBorderColor;
    VisualColor m_rightBorderColor;
    VisualShapeColor m_nodeColor;

    VisualColor m_gateDefaultColor;
    VisualColor m_gateTypeColor[GATE_TYPE_COUNT];

    VisualColor m_preChannelPolylineColor;
    VisualColor m_postChannelPolylineColor;

    VisualShapeColor m_channelWidthLeftColor;
    VisualShapeColor m_channelWidthRightColor;

    static const char* GetGateTypeText(GateType gateType);

    KyFloat32 m_nodeRenderRadius;
    KyFloat32 m_verticalOffset;
    KyFloat32 m_gateHeight;
};

class Gate
{
public:
    Gate()
        : m_type(UndefinedGateType)
        , m_leftWidth(0.0f)
        , m_rightWidth(0.0f)
    {}

    Gate(const Vec3f& leftPos, const Vec3f& pathPos, const Vec3f& rightPos, GateType gateType)
        : m_type(gateType)
        , m_leftPos(leftPos)
        , m_pathPos(pathPos)
        , m_rightPos(rightPos)
        , m_leftWidth(0.0f)
        , m_rightWidth(0.0f)
    {}

    GateType m_type;
    Vec3f m_leftPos;
    Vec3f m_pathPos;
    Vec3f m_rightPos;
    KyFloat32 m_leftWidth;
    KyFloat32 m_rightWidth;
};

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const Gate& g)
{
    os << "[l=" << g.m_leftPos << ", p=" << g.m_pathPos << ", r=" << g.m_rightPos;
    switch (g.m_type)
    {
    case UndefinedGateType    :   os << ", type=UndefinedGateType    ]";   break;
    case StartGate            :   os << ", type=StartGate            ]";   break;
    case EndGate              :   os << ", type=EndGate              ]";   break;
    case SmallLeftTurn        :   os << ", type=SmallLeftTurn        ]";   break;
    case LeftTurnStart        :   os << ", type=LeftTurnStart        ]";   break;
    case LeftTurnIntermediary :   os << ", type=LeftTurnIntermediary ]";   break;
    case LeftTurnEnd          :   os << ", type=LeftTurnEnd          ]";   break;
    case SmallRightTurn       :   os << ", type=SmallRightTurn       ]";   break;
    case RightTurnStart       :   os << ", type=RightTurnStart       ]";   break;
    case RightTurnIntermediary:   os << ", type=RightTurnIntermediary]";   break;
    case RightTurnEnd         :   os << ", type=RightTurnEnd         ]";   break;
    case WidthAdjustment      :   os << ", type=WidthAdjustment      ]";   break;
    case ClampingAdjustment   :   os << ", type=ClampingAdjustment   ]";   break;

    default:   os << ", !!! wrong gate type (" << g.m_type << ") !!!]";   break;
    }

    return os;
}


enum ChannelSide
{
    ChannelLeftSide,
    ChannelRightSide
};




class Channel : public RefCountBase<Channel, MemStat_Channel>
{
public:
    Channel()
        : m_firstPathNodeIdx(0)
    {}

    ~Channel();


    // ------- Main API Functions --------

    KyUInt32 GetGateCount() const;
    const Gate& GetGate(KyUInt32 index) const;

    const KyArray<Vec2f>& GetPreChannelPolyline() const;
    const KyArray<Vec2f>& GetPostChannelPolyline() const;

    KyUInt32 GetSectionCount() const; // GateCount + 1
    KyUInt32 GetLastSectionIdx() const; // (SectionCount - 1) = GateCount
    KyUInt32 GetSectionStartGateIdx(KyUInt32 sectionIdx) const;
    KyUInt32 GetSectionEndGateIdx(KyUInt32 sectionIdx) const;
    const Gate& GetSectionStartGate(KyUInt32 sectionIdx) const;
    const Gate& GetSectionEndGate(KyUInt32 sectionIdx) const;

    const Vec3f& GetEndPos() const;

    KyUInt32 GetFirstPathNodeIdx() const;

    KyUInt32 GetGatePathNodeIdx(KyUInt32 gateIndex) const;

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

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

    KyResult GetSectionFromPositionAndSeed(const Kaim::Vec3f& previousPosition, KyUInt32 previousSectionIdx, const Kaim::Vec3f& newPosition, KyUInt32& newSectionIdx) const;

    KyResult GetSectionFromPositionAndSeed_AlongBubble(const Bubble& bubble, const Kaim::Vec3f& previousPosition, KyUInt32 previousSectionIdx, const Kaim::Vec3f& newPosition, KyUInt32& newSectionIdx) const;

    bool IsConcaveCorner(KyUInt32 gateIdx, ChannelSide side) const;

public: // internal
    KyResult GetSectionFromPositionAndSeed(const Kaim::Vec3f& previousPosition, KyUInt32 previousSectionIdx, const Kaim::Vec3f& newPosition, KyUInt32& newSectionIdx, KyFloat32 maxProgress) const;
    KyResult GetSectionFromPositionAndSeed_Forward(const Kaim::Vec3f& previousPosition, KyUInt32 previousGateIdx, const Kaim::Vec3f& newPosition, KyUInt32& newGateIdx, KyFloat32 maxProgress) const;
    KyResult GetSectionFromPositionAndSeed_Backward(const Kaim::Vec3f& previousPosition, KyUInt32 previousGateIdx, const Kaim::Vec3f& newPosition, KyUInt32& newGateIdx, KyFloat32 maxProgress) const;

    bool IntersectSegmentVsPreChannelPolyline(const Vec2f& A, const Vec2f& B, Vec2f& intersection) const;
    bool IntersectSegmentVsPostChannelPolyline(const Vec2f& A, const Vec2f& B, Vec2f& intersection) const;

    void SendVisualDebug(World* navWorld, const ChannelDisplayConfig& displayConfig = ChannelDisplayConfig(), KyUInt32 indexInChannelArray = 0, const char* listBaseName = "", const char* groupName = "Channel", KyUInt32 visualDebugId = KyUInt32MAXVAL) const;

    // --------  Creation functions ------

    KyResult InitFromBlob(const ChannelBlob& channelBlob);

    void Initialize();
    void Clear();
    void AddGate(const Gate& gate);
    Gate& GetGate(KyUInt32 index);
    void SetPreChannelPolyline(const KyArray<Vec2f>& polyline);
    void SetPostChannelPolyline(const KyArray<Vec2f>& polyline);
    void SetPolylineFromBlob(const BlobArray<Vec2f>& polylineBlob, KyArray<Vec2f>& polyline);

    void SetFirstPathNodeIdx(KyUInt32 firstPathNodeIdx) { m_firstPathNodeIdx = firstPathNodeIdx; }

    KyResult ComputeChannelWidth();

public: // internal : to be used with lot of precaution
    // Computes if the given position is inside the polyline, with polyline being
    // a function on its closure segment (for each point P along the polyline, its
    // orthogonal projection M on the closure segment is so that [MP[ doesn't
    // intersect the polyline.
    // Beware to check if position is before the closure segment, if it is consider position out of polyline
    // using Intersections::IsOnTheLeftOfSegment2d(position, polyline[0], polyline[polyline.GetCount()]).
    bool IsInsidePolyline(const Vec2f& position, const KyArray<Vec2f>& polyline) const;

    bool IntersectSegmentVsPolyline(const Vec2f& A, const Vec2f& B, const KyArray<Vec2f>& polyline, Vec2f& intersection) const;
    bool IsPositionWithinSectionBorders(const Vec2f& newPos2d, const Vec2f& A, const Vec2f& B, const Vec2f& C, const Vec2f& D) const;

    KyResult ComputeChannelWidth_GateLeftCorner(KyUInt32 gateIdx);
    KyResult ComputeChannelWidth_LeftSideForward(KyUInt32 gateIdx, const Vec2f& computedGateLeftPos2d, const Vec2f& computedGateRightPos2d, KyFloat32& gateLeftSquareWidth);
    KyResult ComputeChannelWidth_LeftSideBackward(KyUInt32 gateIdx, const Vec2f& computedGateLeftPos2d, const Vec2f& computedGateRightPos2d, KyFloat32& gateLeftSquareWidth);

    KyResult ComputeChannelWidth_GateRightCorner(KyUInt32 gateIdx);
    KyResult ComputeChannelWidth_RightSideForward(KyUInt32 gateIdx, const Vec2f& computedGateLeftPos2d, const Vec2f& computedGateRightPos2d, KyFloat32& gateRightSquareWidth);
    KyResult ComputeChannelWidth_RightSideBackward(KyUInt32 gateIdx, const Vec2f& computedGateLeftPos2d, const Vec2f& computedGateRightPos2d, KyFloat32& gateRightSquareWidth);

public: // internal
    KyArray<Gate> m_gates;
    KyArray<Vec2f> m_preChannelPolyline;
    KyArray<Vec2f> m_postChannelPolyline;
    KyUInt32 m_firstPathNodeIdx;
};

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

KY_INLINE KyUInt32    Channel::GetGateCount()          const { return m_gates.GetCount(); }
KY_INLINE const Gate& Channel::GetGate(KyUInt32 index) const { return m_gates[index]; }

KY_INLINE const KyArray<Vec2f>& Channel::GetPreChannelPolyline()  const { return m_preChannelPolyline;  }
KY_INLINE const KyArray<Vec2f>& Channel::GetPostChannelPolyline() const { return m_postChannelPolyline; }

KY_INLINE KyUInt32    Channel::GetSectionCount()                           const { KyUInt32 count = GetGateCount(); return (count ? (count + 1) : 0); }
KY_INLINE KyUInt32    Channel::GetLastSectionIdx()                         const { return m_gates.GetCount(); }
KY_INLINE KyUInt32    Channel::GetSectionStartGateIdx(KyUInt32 sectionIdx) const { return Kaim::Max<KyUInt32>(sectionIdx, 1) - 1; }
KY_INLINE KyUInt32    Channel::GetSectionEndGateIdx(KyUInt32 sectionIdx)   const { return Kaim::Min<KyUInt32>(sectionIdx, GetGateCount() - 1); }
KY_INLINE const Gate& Channel::GetSectionStartGate(KyUInt32 sectionIdx)    const { return GetGate(GetSectionStartGateIdx(sectionIdx)); }
KY_INLINE const Gate& Channel::GetSectionEndGate(KyUInt32 sectionIdx)      const { return GetGate(GetSectionEndGateIdx(sectionIdx)); }

KY_INLINE const Vec3f& Channel::GetEndPos() const { return m_gates[GetGateCount() - 1].m_pathPos; }

KY_INLINE bool Channel::IntersectSegmentVsPreChannelPolyline(const Vec2f& A, const Vec2f& B, Vec2f& intersection)  const { return IntersectSegmentVsPolyline(A, B, m_preChannelPolyline , intersection); }
KY_INLINE bool Channel::IntersectSegmentVsPostChannelPolyline(const Vec2f& A, const Vec2f& B, Vec2f& intersection) const { return IntersectSegmentVsPolyline(A, B, m_postChannelPolyline, intersection); }

KY_INLINE void     Channel::Initialize()                  { Clear(); }

KY_INLINE void     Channel::Clear()
{
    m_gates.Clear();
    m_preChannelPolyline.Clear();
    m_postChannelPolyline.Clear();
}

KY_INLINE void     Channel::AddGate(const Gate& gate)     { m_gates.PushBack(gate); }
KY_INLINE Gate&    Channel::GetGate(KyUInt32 index)       { return m_gates[index]; }

KY_INLINE void     Channel::SetPreChannelPolyline(const KyArray<Vec2f>& polyline) { m_preChannelPolyline = polyline; }
KY_INLINE void     Channel::SetPostChannelPolyline(const KyArray<Vec2f>& polyline) { m_postChannelPolyline = polyline; }

KY_INLINE KyUInt32 Channel::GetFirstPathNodeIdx() const                  { return m_firstPathNodeIdx; }
KY_INLINE KyUInt32 Channel::GetGatePathNodeIdx(KyUInt32 gateIndex) const { return m_firstPathNodeIdx + gateIndex; }

KY_INLINE bool Channel::IsPositionInSection(const Vec2f& position, KyUInt32 sectionIndex) const
{
    KyUInt32 unusedPositionFlags;
    return IsPositionInSection(position, sectionIndex, unusedPositionFlags);
}

} // namespace Kaim

#endif // Navigation_Channel_H