bubble.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_Bubble_H
#define Navigation_Bubble_H


#include "gwnavruntime/channel/funnel.h"
#include "gwnavruntime/math/vec3f.h"
#include "gwnavruntime/math/rotation.h"
#include "gwnavruntime/containers/stringstream.h"


namespace Kaim
{

class ScopedDisplayList;
class BubbleBlob;



enum BubbleType
{
    UndefinedBubbleType,
    StartBubble,
    EndBubble,
    IntermediaryBubble
};

class Bubble
{
public:
    Bubble();
    Bubble(const Vec3f& center, KyFloat32 radius, RotationDirection rotationDirection, BubbleType type = UndefinedBubbleType);

    void Reset();
    void Set(const Vec3f& center, KyFloat32 radius, RotationDirection rotationDirection, BubbleType type = UndefinedBubbleType);

    void InitFromBlob(const BubbleBlob& blob);

    void SetCenter(const Vec3f& center);
    void SetRadius(KyFloat32 radius);
    void SetRotationDirection(RotationDirection rotationDirection);
    void SetType(BubbleType type);

    void SetCenterAltitude(KyFloat32 newCenterAltitude);

    const Vec3f&      GetCenter()            const;
    KyFloat32         GetRadius()            const;
    RotationDirection GetRotationDirection() const;
    BubbleType        GetType()              const;
    FunnelSide        GetFunnelSide()        const;

    bool              IsInitialized()        const;

    KyResult ComputeBiTangentDirection(const Bubble& arrivalBubble, Vec2f& biTangentDir) const;

    KyResult ComputeBiTangent(const Bubble& arrivalBubble, Vec2f& biTangentStart, Vec2f& biTangentEnd, Vec2f& biTangentNormalizedDir) const;
    KyResult ComputeBiTangent(const Bubble& arrivalBubble, Vec2f& biTangentStart, Vec2f& biTangentEnd) const;

    KyResult ComputeBiTangent(const Bubble& arrivalBubble, Vec3f& biTangentStart, Vec3f& biTangentEnd, Vec2f& biTangentNormalizedDir) const;
    KyResult ComputeBiTangent(const Bubble& arrivalBubble, Vec3f& biTangentStart, Vec3f& biTangentEnd) const;

    KyResult ComputeBiTangentBubble(const Vec3f& tangencyPosition, const Bubble& secondBubble, Vec3f& tangencyPositionOnSecondBubble, Bubble& biTangentBubble) const;

    KyResult ComputeTangentBubble(const Vec3f& tangencyPosition, const Vec3f& position, Bubble& tangentBubble) const;

    void ComputeMedianTurnAxisAndPoint(const Vec2f& entryDir, const Vec2f& exitDir, Vec2f &medianTurnAxis, Vec3f& midPoint) const;

    void Display(ScopedDisplayList& displayList) const;

    bool operator==(const Bubble& other) const;
private:
    Vec3f m_center;
    KyFloat32 m_radius;
    RotationDirection m_rotationDirection;
    BubbleType m_type;
};

KY_INLINE Bubble::Bubble() { Reset(); }
KY_INLINE Bubble::Bubble(const Vec3f& center, KyFloat32 radius, RotationDirection rotationDirection, BubbleType type)
{
    Set(center, radius, rotationDirection, type);
}
KY_INLINE void Bubble::Reset()
{
    Set(Vec3f::Zero(), 0.0f, UninitializedRotationDirection, UndefinedBubbleType);
}
KY_INLINE void Bubble::Set(const Vec3f& center, KyFloat32 radius, RotationDirection rotationDirection, BubbleType type)
{
    SetCenter(center);
    SetRadius(radius);
    SetRotationDirection(rotationDirection);
    SetType(type);
}

KY_INLINE void Bubble::SetCenter(const Vec3f& center)                            { m_center = center;                       }
KY_INLINE void Bubble::SetRadius(KyFloat32 radius)                               { m_radius = radius;                       }
KY_INLINE void Bubble::SetRotationDirection(RotationDirection rotationDirection) { m_rotationDirection = rotationDirection; }
KY_INLINE void Bubble::SetType(BubbleType type)                                  { m_type = type;                           }
KY_INLINE void Bubble::SetCenterAltitude(KyFloat32 newCenterAltitude)            { m_center.z = newCenterAltitude;          }

KY_INLINE const Vec3f&      Bubble::GetCenter()            const { return m_center;            }
KY_INLINE KyFloat32         Bubble::GetRadius()            const { return m_radius;            }
KY_INLINE RotationDirection Bubble::GetRotationDirection() const { return m_rotationDirection; }
KY_INLINE BubbleType        Bubble::GetType()              const { return m_type;              }

KY_INLINE bool Bubble::IsInitialized() const { return m_rotationDirection != UninitializedRotationDirection; }

KY_INLINE KyResult Bubble::ComputeBiTangent(const Bubble& arrivalBubble, Vec2f& biTangentStart, Vec2f& biTangentEnd) const
{
    Vec2f unused;
    return ComputeBiTangent(arrivalBubble, biTangentStart, biTangentEnd, unused);
}
KY_INLINE FunnelSide Bubble::GetFunnelSide() const
{
    if (m_type != IntermediaryBubble)
        return FunnelBothSides;

    return (
        (m_rotationDirection == Clockwise       ) ? FunnelRight :
        (m_rotationDirection == CounterClockwise) ? FunnelLeft  :
        UndefinedFunnelSide);
}
KY_INLINE KyResult Bubble::ComputeBiTangent(const Bubble& arrivalBubble, Vec3f& biTangentStart, Vec3f& biTangentEnd) const
{
    Vec2f unused; 
    return ComputeBiTangent(arrivalBubble, biTangentStart, biTangentEnd, unused);
}

inline bool Bubble::operator==(const Bubble& other) const
{
    return 
        m_center            == other.m_center            &&
        m_radius            == other.m_radius            &&
        m_rotationDirection == other.m_rotationDirection &&
        m_type              == other.m_type              ;
}



template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const Bubble& bubble)
{
    os << "center=" << bubble.GetCenter() << " radius=" << bubble.GetRadius() << " direction=" << GetRotationDirectionLabel(bubble.GetRotationDirection());
    return os;
}

} // namespace Kaim

#endif // Navigation_Bubble_H