diagonalstrip.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/bubble.h"

#include "gwnavruntime/math/vec3f.h"
#include "gwnavruntime/containers/sharedpoollist.h"
#include "gwnavruntime/visualsystem/displaylistblob.h"

namespace Kaim
{

class DisplayListManager;
class DisplayListIdArray;

class DiagonalStripDisplayListIds
{
public:
    DiagonalStripDisplayListIds()
        : m_left(KyUInt32MAXVAL)
        , m_right(KyUInt32MAXVAL)
        , m_corners(KyUInt32MAXVAL)
        , m_nearestOpposite(KyUInt32MAXVAL)
        , m_diskToNearestOpposite(KyUInt32MAXVAL)
        , m_diagonals(KyUInt32MAXVAL)
        , m_cornerIdx(KyUInt32MAXVAL)
        , m_triangles(KyUInt32MAXVAL)
    {}

    void RemoveAll(DisplayListManager* displayListManager);

public:
    KyUInt32 m_left;
    KyUInt32 m_right;
    KyUInt32 m_corners;
    KyUInt32 m_nearestOpposite;
    KyUInt32 m_diskToNearestOpposite;
    KyUInt32 m_diagonals;
    KyUInt32 m_cornerIdx;
    KyUInt32 m_triangles;
};

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

    KyFloat32 m_contourVerticalOffset;
    ShapeColor m_triangleColor;
    Color m_leftColor;
    Color m_rightColor;
    ShapeColor m_cornerDiskColor;
    ShapeColor m_diagonalColor;
};


enum CornerType
{
    UndefinedCornerType, // only when not initialized.
    PathStart,           // used only in string pulled path
    PathEnd,             // used only in string pulled path
    LeftSide,
    RightSide
};

class StripCorner
{
public:
    StripCorner()
        : m_cornerType(UndefinedCornerType)
        , m_maxRadius(0.0f)
    {}

    StripCorner(const Vec3f& position, CornerType cornerType, KyFloat32 maxRadius)
    {
        Set(position, cornerType, maxRadius);
    }

    static CornerType GetOppositeSide(CornerType cornerType)
    {
        switch (cornerType)
        {
        case LeftSide:              return RightSide;
        case RightSide:             return LeftSide;
        default:                    return cornerType;
        }
    }

    void Set(const Vec3f& position, CornerType cornerType, KyFloat32 maxRadius)
    {
        m_position = position;
        m_cornerType = cornerType;
        m_maxRadius = maxRadius;
        m_oppositeNearestPositionIsSet = false;
    }

    void SetCornerNearestOppositePosition(const Vec3f& nearestOppositePosition)
    {
        SetMaxRadius(0.49f * Distance2d(m_position, nearestOppositePosition));
        m_oppositeNearestPosition = nearestOppositePosition;
        m_oppositeNearestPositionIsSet = true;
    }

    void SetMaxRadius(KyFloat32 maxRadius)
    {
        m_maxRadius = maxRadius;
    }

    void PreciseType(CornerType cornerType) { m_cornerType = cornerType; }

    const Vec3f& GetPosition()   const { return m_position;   }
    CornerType   GetCornerType() const { return m_cornerType; }
    KyFloat32    GetMaxRadius()  const { return m_maxRadius;  }

    bool         IsOppositeNearestPositionSet() const { return m_oppositeNearestPositionIsSet; }
    const Vec3f& GetOppositeNearestPosition()   const { return m_oppositeNearestPosition;      }

    bool IsValid() const
    {
        return (m_cornerType != UndefinedCornerType);
    }


public:
    friend class DiagonalStrip;

    Vec3f m_position;
    CornerType m_cornerType;
    KyFloat32 m_maxRadius;

    Vec3f m_oppositeNearestPosition;
    bool m_oppositeNearestPositionIsSet;
};

KY_INLINE RotationDirection GetBubbleRotationDirectionFromCornerType(CornerType cornerType)
{
    return
        (cornerType == LeftSide) ? CounterClockwise :
        (cornerType == RightSide) ? Clockwise :
        UndefinedRotationDirection;
}

KY_INLINE FunnelSide GetFunnelSideFromCornerType(CornerType cornerType)
{
    return
        (cornerType == LeftSide) ? FunnelLeft :
        (cornerType == RightSide) ? FunnelRight :
        FunnelBothSides;
}


class NearestOppositePositionUpdator
{
public:
    NearestOppositePositionUpdator(const Vec3f& position)
        : m_position(position)
        , m_nearestPosition(KyFloat32MAXVAL, KyFloat32MAXVAL, KyFloat32MAXVAL)
        , m_minSqDist(KyFloat32MAXVAL)
    {}

    void UpdateWithOppositeSegment(const Vec3f& A, const Vec3f& B);

    Vec3f m_position;
    Vec3f m_nearestPosition;
    KyFloat32 m_minSqDist;
};


class DiagonalStrip
{
public:
    enum GetBorderResult
    {
        BorderFound,
        BorderNotFound,
        NearestFoundIsStartOrEnd,
        AskedCornerIsDiagonalStripStartOrEnd
    };

    DiagonalStrip() {}

    void PushBackCorner(const Vec3f& position, CornerType cornerType, KyFloat32 maxRadius)
    {
        StripCorner corner(position, cornerType, maxRadius);
        m_corners.PushBack(corner);
    }

    void Clear();
    void SendVisualDebug(DisplayListManager* displayListManager, DiagonalStripDisplayListIds& displayListIds, const DiagonalStripDisplayConfig& displayConfig = DiagonalStripDisplayConfig());

    bool               IsEmpty()                     const { return m_corners.IsEmpty();  }
    KyUInt32           GetCornerCount()              const { return m_corners.GetCount(); }
    const StripCorner& GetCorner(KyUInt32 cornerIdx) const { return m_corners[cornerIdx]; }
          StripCorner& GetCorner(KyUInt32 cornerIdx)       { return m_corners[cornerIdx]; }

    KyUInt32 GetIncomingBorderStartIdx(KyUInt32 cornerIdx) const;
    KyUInt32 GetOutgoingBorderEndIdx(KyUInt32 cornerIdx) const;
    StripCorner GetIncomingBorderStart(KyUInt32 cornerIdx) const;
    StripCorner GetOutgoingBorderEnd(KyUInt32 cornerIdx) const;
    GetBorderResult GetNearestOppositeSidePosition(KyUInt32 cornerIdx, KyFloat32 searchRadius, Vec3f& nearestPosition) const;

    void SetCornerRadius(KyUInt32 cornerIdx, KyFloat32 cornerRadius)            { m_corners[cornerIdx].m_maxRadius = cornerRadius; }
    void SetCornerNearestOppositePosition(KyUInt32 cornerIdx, const Vec3f& pos) { m_corners[cornerIdx].SetCornerNearestOppositePosition(pos); }
    void SetCornerMaxRadius(KyUInt32 cornerIdx, KyFloat32 maxRadius)            { m_corners[cornerIdx].SetMaxRadius(maxRadius); }

    KyUInt32 GetLastCornerIdxOfType(CornerType cornerType);
    void ChangePosOfLastCorner(CornerType cornerType, const Vec3f& pos);
    bool GetLastButOneCornerPos(CornerType cornerType, Vec3f& pos) const;
    StripCorner& GetLastCorner(CornerType cornerType);

private:
    void SendDiagonalStripVisualDebug(DisplayListManager* displayListManager, DiagonalStripDisplayListIds& displayListIds, const DiagonalStripDisplayConfig& displayConfig);
    void ApplyToVisibleOppositeSegmentsForward(NearestOppositePositionUpdator& updator, KyUInt32 cornerIdx, KyFloat32 searchRadius) const;
    void ApplyToVisibleOppositeSegmentsBackward(NearestOppositePositionUpdator& updator, KyUInt32 cornerIdx, KyFloat32 searchRadius) const;

public:
    KyArray<StripCorner> m_corners;
};


inline KyUInt32 DiagonalStrip::GetLastCornerIdxOfType(CornerType cornerType)
{
    KY_ASSERT(GetCornerCount() > 0);
    KyUInt32 cornerIdx = GetCornerCount() - 1;
    for(;;)
    {
        StripCorner& corner = GetCorner(cornerIdx);
        if (corner.GetCornerType() == cornerType)
            return cornerIdx;

        if (cornerIdx == 0)
            return KyUInt32MAXVAL;

        --cornerIdx;
    }
}

inline void DiagonalStrip::ChangePosOfLastCorner(CornerType cornerType, const Vec3f& pos)
{
    KY_ASSERT(GetCornerCount() > 0);
    KyUInt32 cornerIdx = GetCornerCount() - 1;
    for(;;)
    {
        StripCorner& corner = GetCorner(cornerIdx);
        if (corner.GetCornerType() == cornerType)
        {
            corner.m_position = pos;
            return;
        }

        if (cornerIdx == 0)
            return;

        --cornerIdx;
    }
}

inline StripCorner& DiagonalStrip::GetLastCorner(CornerType cornerType)
{
    KY_ASSERT(GetCornerCount() > 0);
    KyUInt32 cornerIdx = GetCornerCount() - 1;
    for(;;)
    {
        StripCorner& corner = GetCorner(cornerIdx);
        if (corner.GetCornerType() == cornerType)
            return corner;

        --cornerIdx;
    }
}

inline bool DiagonalStrip::GetLastButOneCornerPos(CornerType cornerType, Vec3f& pos) const
{
    KY_ASSERT(GetCornerCount() > 0);
    KyUInt32 cornerIdx = GetCornerCount() - 1;
    bool foundOne = false;
    for(;;)
    {
        const StripCorner& corner = GetCorner(cornerIdx);
        if (corner.GetCornerType() == cornerType)
        {
            if (foundOne)
            {
                pos = corner.GetPosition();
                return true;
            }

            foundOne = true;
        }

        if (cornerIdx == 0)
            break;

        --cornerIdx;
    }

    return false;
}

} // namespace Kaim