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


// primary contact: GUAL - secondary contact: NOBODY
#ifndef Navigation_Box2LL_H
#define Navigation_Box2LL_H

#include "gwnavruntime/math/vec2ll.h"
#include "gwnavruntime/math/triangle3i.h"


namespace Kaim
{


class Box2LL
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

public:
    // ---------------------------------- Constructors ----------------------------------

    Box2LL() { Clear(); }

    Box2LL(const Vec2LL& min_, const Vec2LL& max_) : m_min(min_), m_max(max_) {}

    Box2LL(KyInt64 min_x, KyInt64 min_y, KyInt64 max_x, KyInt64 max_y) : m_min(min_x, min_y), m_max(max_x, max_y) {}


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

    KY_INLINE bool IsValid() { return CountX() >= 0 && CountY() >= 0; }

    KY_INLINE void MakeZero() { m_min.Set(0, 0); m_max.Set(0, 0); }

    KY_INLINE void Set(const Vec2LL& min_, const Vec2LL& max_) { m_min = min_; m_max = max_; }

    KY_INLINE void SetMin(const Vec2LL& min_) { m_min = min_; }

    KY_INLINE void SetMax(const Vec2LL& max_) { m_max = max_; }

    KY_INLINE const Vec2LL& Min() const { return m_min; }

    KY_INLINE const Vec2LL& Max() const { return m_max; }

    KY_INLINE Vec2LL CornerSouthWest() const { return m_min; }

    KY_INLINE Vec2LL CornerNorthEast() const { return m_max; }

    KY_INLINE Vec2LL CornerSouthEast() const { return Vec2LL(m_max.x, m_min.y); }

    KY_INLINE Vec2LL CornerNorthWest() const { return Vec2LL(m_min.x, m_max.y); }

    KY_INLINE bool IsInside(const Vec2LL& pos) const { return pos.x >= m_min.x && pos.x <= m_max.x && pos.y >= m_min.y && pos.y <= m_max.y; }

    KY_INLINE bool IsInsideStrictly(const Vec2LL& pos) const { return pos.x >  m_min.x && pos.x <  m_max.x && pos.y >  m_min.y && pos.y <  m_max.y; }

    void Clear()
    {
        m_min.Set(KyInt64MAXVAL, KyInt64MAXVAL);
        m_max.Set(-KyInt64MAXVAL, -KyInt64MAXVAL);
    }

    KY_INLINE Box2LL& operator*=(KyInt64 s) { m_min *= s; m_max *= s; return *this; }

    KY_INLINE Box2LL& operator/=(KyInt64 s) { m_min /= s; m_max /= s; return *this; }

    KY_INLINE Box2LL& operator+=(const Vec2LL& v) { m_min += v; m_max += v; return *this; }

    KY_INLINE Box2LL& operator-=(const Vec2LL& v) { m_min -= v; m_max -= v; return *this; }

    KY_INLINE bool operator==(const Box2LL& other) const { return other.m_min == m_min && other.m_max == m_max; }

    void ExpandByVec2(const Vec2LL& pos)
    {
        ExpandByVec2_MinMaxOnly(pos);
    }

    void ExpandByBox2(const Box2LL& box)
    {
        ExpandByVec2_MinMaxOnly(box.m_min);
        ExpandByVec2_MinMaxOnly(box.m_max);
    }

    void Enlarge(KyInt64 enlargement)
    {
        m_min -= enlargement;
        m_max += enlargement;
    }

    void GetEnlarged(KyInt64 enlargement, Box2LL& enlarged) const
    {
        enlarged = *this;
        enlarged.Enlarge(enlargement);
    }

    bool IntersectWith(const Box2LL& box)
    {
        m_min.x = Kaim::Max(m_min.x, box.m_min.x);
        m_max.x = Kaim::Min(m_max.x, box.m_max.x);
        m_min.y = Kaim::Max(m_min.y, box.m_min.y);
        m_max.y = Kaim::Min(m_max.y, box.m_max.y);
        return CountX() > 0 && CountY() > 0;
    }

    bool SetAsIntersection(const Box2LL& box_1, const Box2LL& box_2)
    {
        m_min.x = Kaim::Max(box_1.m_min.x, box_2.m_min.x);
        m_max.x = Kaim::Min(box_1.m_max.x, box_2.m_max.x);
        m_min.y = Kaim::Max(box_1.m_min.y, box_2.m_min.y);
        m_max.y = Kaim::Min(box_1.m_max.y, box_2.m_max.y);
        return CountX() > 0 && CountY() > 0;
    }

private:
    KY_INLINE KyInt64 CountX() { return m_max.x - m_min.x + 1; }
    KY_INLINE KyInt64 CountY() { return m_max.y - m_min.y + 1; }

    void ExpandByVec2_MinMaxOnly(const Vec2LL& pos)
    {
        const KyInt64 posx = pos.x;
        const KyInt64 posy = pos.y;
        m_min.x = Kaim::Min(m_min.x, posx);
        m_max.x = Kaim::Max(m_max.x, posx);
        m_min.y = Kaim::Min(m_min.y, posy);
        m_max.y = Kaim::Max(m_max.y, posy);
    }


public:
    Vec2LL m_min;
    Vec2LL m_max;
};


template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const Kaim::Box2LL& v)
{
    os << "{" << v.Min() << ";" << v.Max() << "}";
    return os;
}


} // namespace Kaim




#endif