box2i.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/fastmath.h"
#include "gwnavruntime/math/triangle3i.h"
#include "gwnavruntime/math/cardinaldir.h"

namespace Kaim
{

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

    Box2i() { Clear(); } 
    Box2i(const Vec2i& min_, const Vec2i& max_) : m_min(min_), m_max(max_) { UpdateCountXY(); }
    Box2i(KyInt32 min_x, KyInt32 min_y, KyInt32 max_x, KyInt32 max_y) : m_min(min_x, min_y), m_max(max_x, max_y) { UpdateCountXY(); }

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

    void Clear()
    {
        m_min.Set(KyInt32MAXVAL, KyInt32MAXVAL);
        m_max.Set(KyInt32MINVAL, KyInt32MINVAL);
        ClearCountXY();
    }

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

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

    void Set(const Vec2i& min_, const Vec2i& max_) { m_min = min_; m_max = max_; UpdateCountXY(); }

    void Set(KyInt32 min_x, KyInt32 min_y, KyInt32 max_x, KyInt32 max_y) { m_min.x = min_x; m_min.y = min_y; m_max.x = max_x; m_max.y = max_y; UpdateCountXY(); }
    void SetSafe(const Vec2i& min_, const Vec2i& max_) { m_min = min_; m_max = max_; UpdateCountXYSafe(); } 

    void SetMin(const Vec2i& min_) { m_min = min_; UpdateCountXY(); }
    void SetMax(const Vec2i& max_) { m_max = max_; UpdateCountXY(); }

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

    const Vec2i& CountXY() const { return m_countXY; } 

    KyInt32 CountX() const { return m_countXY.x; } 
    KyInt32 CountY() const { return m_countXY.y; } 

    // ------------------------------ East North West South -----------------------------

    KyInt32 East()  const { return m_max.x; }
    KyInt32 North() const { return m_max.y; }
    KyInt32 West()  const { return m_min.x; }
    KyInt32 South() const { return m_max.y; }

    Vec2i NorthEast() const { return m_max; }
    Vec2i NorthWest() const { return Vec2i(m_min.x, m_max.y); }
    Vec2i SouthWest() const { return m_min; }
    Vec2i SouthEast() const { return Vec2i(m_max.x, m_min.y); }

    // ------------------------------ DoesContain -----------------------------

    bool DoesContain(const Vec2i& pos) const { return pos.x >= m_min.x && pos.x <= m_max.x && pos.y >= m_min.y && pos.y <= m_max.y; }

    bool DoesContainStrictly(const Vec2i& pos) const { return pos.x >  m_min.x && pos.x <  m_max.x && pos.y >  m_min.y && pos.y <  m_max.y; }

    bool DoesContainNeighbor(const Vec2i& pos, CardinalDir dir) const
    {
        switch (dir)
        {
        case CardinalDir_EAST:         return pos.x < m_max.x;
        case CardinalDir_NORTH:        return pos.y < m_max.y;
        case CardinalDir_WEST:         return pos.x > m_min.x;
        default: /*CardinalDir_SOUTH*/ return pos.y > m_min.y;
        }
    }

    // ------------------------------ Index -----------------------------

    KyInt32 GetRowMajorIndex(const Vec2i& pos) const { return (pos.y - m_min.y) * CountX() + pos.x - m_min.x; }

    KyInt32 GetRowMajorIndexFromLocalPos(const Vec2i& localPos) const { return localPos.y * CountX() + localPos.x; }

    // ------------------------------ Expand -----------------------------

    void ExpandByPos(const Vec2i& pos)
    {
        ExpandByVec2_MinMaxOnly(pos);
        UpdateCountXY();
    }

    void ExpandByPos(const Vec3i& pos)
    {
        ExpandByVec3_MinMaxOnly(pos);
        UpdateCountXY();
    }

    void ExpandByTriangle(const Triangle3i& triangle)
    {
        ExpandByVec3_MinMaxOnly(triangle.A);
        ExpandByVec3_MinMaxOnly(triangle.B);
        ExpandByVec3_MinMaxOnly(triangle.C);
        UpdateCountXY();
    }

    void ExpandByBox(const Box2i& 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);
        UpdateCountXY();
    }

    // ------------------------------ Enlarge -----------------------------

    void Enlarge(KyInt32 enlargement)
    {
        Vec2i e(enlargement, enlargement);
        m_min -= e;
        m_max += e;
        UpdateCountXY();
    }

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

    Box2i GetEnlarged(KyInt32 enlargement) const
    {
        Vec2i e(enlargement, enlargement);
        return Box2i(m_min - e, m_max + e);
    }

    // ------------------------------ Intersect -----------------------------

    bool IntersectWith(const Box2i& box) { return this->SetAsIntersection(*this, box); }

    bool DoesIntersectWith(const Box2i& box) const
    {
        KyInt32 min_x = Kaim::Max(m_min.x, box.m_min.x);
        KyInt32 max_x = Kaim::Min(m_max.x, box.m_max.x);
        KyInt32 min_y = Kaim::Max(m_min.y, box.m_min.y);
        KyInt32 max_y = Kaim::Min(m_max.y, box.m_max.y);
        return (min_x <= max_x && min_y <= max_y);
    }

    bool SetAsIntersection(const Box2i& box_1, const Box2i& 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);

        if (m_min.x <= m_max.x && m_min.y <= m_max.y)
        {
            UpdateCountXY();
            return true;
        }

        Clear();
        return false;
    }

private:
    void UpdateCountX()  { m_countXY.x = m_max.x - m_min.x + 1; }
    void UpdateCountY()  { m_countXY.y = m_max.y - m_min.y + 1; }
    void UpdateCountXY() { UpdateCountX(); UpdateCountY(); }
    void ClearCountXY()  { m_countXY.x = -1; m_countXY.y = -1; }

    void UpdateCountXYSafe()
    {
        KyInt64 countX = (KyInt64)m_max.x - (KyInt64)m_min.x + 1;
        KyInt64 countY = (KyInt64)m_max.y - (KyInt64)m_min.y + 1;
        if (countX < 0 || countY < 0 || countX > KyInt32MAXVAL || countY > KyInt32MAXVAL)
        {
            Clear();
            return;
        }

        m_countXY.x = (KyInt32)countX;
        m_countXY.y = (KyInt32)countY;
    }

    void ExpandByVec2_MinMaxOnly(const Vec2i& pos)
    {
        const KyInt32 posx = pos.x;
        const KyInt32 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);
    }

    void ExpandByVec3_MinMaxOnly(const Vec3i& pos)
    {
        const KyInt32 posx = pos.x;
        const KyInt32 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:
    // ------------------------------ Public Data -----------------------------
    Vec2i m_min;
    Vec2i m_max;

private:
    Vec2i m_countXY;

    friend void SwapEndianness(Endianness::Target e, Box2i& self);
    friend class GridUtils;
};

inline void SwapEndianness(Endianness::Target e, Box2i& self)
{
    SwapEndianness(e, self.m_min);
    SwapEndianness(e, self.m_max);
    SwapEndianness(e, self.m_countXY);
}

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

}