box2ll.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/math/vec2ll.h"
#include "gwnavruntime/math/triangle3i.h"

namespace Kaim
{

class Box2LL
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)
public:
    // ------------------------------ Functions -----------------------------

    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) {}

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

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

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

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

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

    const Vec2LL& Min() const { return m_min; }
    const Vec2LL& Max() const { return m_max; }

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

    bool DoesContain(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; }

    bool DoesStrictlyContain(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 ExpandByPos(const Vec2LL& pos)
    {
        m_min.x = Kaim::Min(m_min.x, pos.x);
        m_max.x = Kaim::Max(m_max.x, pos.x);
        m_min.y = Kaim::Min(m_min.y, pos.y);
        m_max.y = Kaim::Max(m_max.y, pos.y);
    }

    void ExpandByBox(const Box2LL& box)
    {
        m_min.x = Kaim::Min(m_min.x, box.m_min.x);
        m_max.x = Kaim::Max(m_max.x, box.m_max.x);
        m_min.y = Kaim::Min(m_min.y, box.m_min.y);
        m_max.y = Kaim::Max(m_max.y, box.m_max.y);
    }

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

    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 IsValid();
    }

    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 IsValid();
    }

    // ------------------------------ Data -----------------------------

    Vec2LL m_min;
    Vec2LL m_max;
};

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

}