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

namespace Kaim
{

class Bubble;
class ChannelBlob;
class DisplayListManager;

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;

    Color m_channelIndexColor;
    Color m_sectionIndexColor;
    Color m_gateIndexColor;
    Color m_pathColor;
    Color m_leftBorderColor;
    Color m_rightBorderColor;
    Color m_nodeColor;

    Color m_gateDefaultColor;
    Color m_gateTypeColor[GATE_TYPE_COUNT];

    Color m_preChannelPolylineColor;
    Color m_postChannelPolylineColor;

    Color m_channelWidthLeftColor;
    Color 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)
    {}

    void Clear()
    {
        m_type = UndefinedGateType;
        m_leftPos.Clear();
        m_pathPos.Clear();
        m_rightPos.Clear();
        m_leftWidth = 0.0f;
        m_rightWidth = 0.0f;
    }

    bool IsCollapsed() const { return m_leftPos == m_rightPos; }

    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 << ", O=" << 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 }; // use struct Side { enum Enum { Left, Right }; };

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

    ~Channel() { Clear(); }

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

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

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

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

    const Vec3f& GetStartPos() const { return m_gates[0].m_pathPos; }

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

    KyUInt32 GetFirstPathNodeIdx() const { return m_firstPathNodeIdx; }

    KyUInt32 GetGatePathNodeIdx(KyUInt32 gateIndex) const { return m_firstPathNodeIdx + gateIndex; }

    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& prevPos, KyUInt32 prevSectionIdx, const Kaim::Vec3f& newPos, KyUInt32& newSectionIdx, KyFloat32 maxProgress) const;
    KyResult GetSectionFromPositionAndSeed_Forward( const Kaim::Vec3f& prevPos, KyUInt32 prevGateIdx   , const Kaim::Vec3f& newPos, KyUInt32& newGateIdx   , KyFloat32 maxProgress) const;
    KyResult GetSectionFromPositionAndSeed_Backward(const Kaim::Vec3f& prevPos, KyUInt32 prevGateIdx   , const Kaim::Vec3f& newPos, KyUInt32& newGateIdx   , KyFloat32 maxProgress) const;

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

    void SendVisualDebug(DisplayListManager* displayListManager, 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() { Clear(); }
    void Clear();
    void AddGate(const Gate& gate) { m_gates.PushBack(gate); }
    Gate& GetGate(KyUInt32 index) { return m_gates[index]; }
    void SetPreChannelPolyline(const KyArray<Vec2f>& polyline)  { m_preChannelPolyline  = polyline; }
    void SetPostChannelPolyline(const KyArray<Vec2f>& polyline) { m_postChannelPolyline = 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 Math::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 void Channel::Clear()
{
    m_gates.Clear();
    m_preChannelPolyline.Clear();
    m_postChannelPolyline.Clear();
}

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

} // namespace Kaim