box2i.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_Box2i_H
#define Navigation_Box2i_H

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


namespace Kaim
{

/*
----------------- CoordBox -----------------
minX=2 , maxX=8 , countX=7 (=8-2 +1)
minY=3 , maxY=6 , countY=4 (=6-3 +1)
 /\Y
 |   |   |   |   |   |   |   |   |   |
7+---+---+---+---+---+---+---+---+---+--
 |   |   |   |   |   |   |   |   |   |
6+---+---#########################---+--
 |   |   #   |   |   |   |   |   #   |
5+---+---#---+---+---+---+---+---#---+--
 |   |   #   |   |   |   |   |   #   |
4+---+---#---+---+---+---+---+---#---+--
 |   |   #   |   |   |   |   |   #   |
3+---+---#########################---+--
 |   |   |   |   |   |   |   |   |   |
2+---+---+---+---+---+---+---+---+---+--
 |   |   |   |   |   |   |   |   |   |
1+---+---+---+---+---+---+---+---+---+--
 |   |   |   |   |   |   |   |   |   |
0+---+---+---+---+---+---+---+---+---+-> X
 0   1   2   3   4   5   6   7   8   9

--------- PixelBox, CellBox, TileBox ---------
minX=2 , maxX=7 , countX=6 (=7-2 +1)
minY=3 , maxY=5 , countY=3 (=5-3 +1)
/\Y
|   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+--
|0,6|1,6|2,6|   |   |   |   |   |   |
+---+---#########################---+--
|0,5|1,5#2,5|3,5|4,5|5,5|6,5|7,5#   |
+---+---#---+---+---+---+---+---#---+--
|0,4|1,4#2,4|3,4|4,4|5,4|6,4|7,4#   |
+---+---#---+---+---+---+---+---#---+--
|0,3|1,3#2,3|3,3|4,3|5,3|6,3|7,3#   |
+---+---#########################---+--
|0,2|1,2|2,2|   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+--
|0,1|1,1|2,1|   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+--
|0,0|1,0|2,0|   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+-> X
*/

class Box2i
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

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


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

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

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

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

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

    KY_INLINE void SetSafe(const Vec2i& min_, const Vec2i& max_) { m_min = min_; m_max = max_; UpdateCountXYSafe(); }

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

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

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

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

    KY_INLINE Vec2i CornerSouthWest() const { return m_min; }

    KY_INLINE Vec2i CornerNorthEast() const { return m_max; }

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

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

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

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

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

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

    KY_INLINE bool FastIsInside(const Vec2i& pos) const
    {
        const KyInt32 operand1 = Isel(pos.x - m_min.x, 1, 0); // operand1 == 1.f if pos.x >= cellBox.m_min.x
        const KyInt32 operand2 = Isel(m_max.x - pos.x, 1, 0); // operand2 == 1.f if cellBox.m_max.x >= pos.x
        const KyInt32 operand3 = Isel(pos.y - m_min.y, 1, 0); // operand3 == 1.f if pos.y >= cellBox.m_min.y
        const KyInt32 operand4 = Isel(m_max.y - pos.y, 1, 0); // operand4 == 1.f if cellBox.m_max.y >= pos.y

        return (operand1 & operand2 & operand3 & operand4) != 0;
    }

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

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

    KY_INLINE Box2i& operator*=(KyInt32 s) { m_min *= s; m_max *= s; UpdateCountXY(); return *this; }

    KY_INLINE Box2i& operator/=(KyInt32 s) { m_min /= s; m_max /= s; UpdateCountXY(); return *this; }

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

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

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


    KY_INLINE KyInt32 GetColumnMajorIndex(const Vec2i& pos) const { return (pos.x - m_min.x) * CountY() + pos.y - m_min.y; }

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

    KY_INLINE KyInt32 GetColumnMajorIndexFromLocalPos(const Vec2i& localPos) const { return localPos.x * CountY() + localPos.y; }

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

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

    void ExpandByVec3(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 ExpandByBox2(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();
    }

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

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

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

    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:
    KY_INLINE void UpdateCountX()  { m_countXY.x = m_max.x - m_min.x + 1; }
    KY_INLINE void UpdateCountY()  { m_countXY.y = m_max.y - m_min.y + 1; }
    KY_INLINE void UpdateCountXY() { UpdateCountX(); UpdateCountY(); }
    KY_INLINE void ClearCountXY()  { m_countXY.x = -1; m_countXY.y = -1; }

    KY_INLINE 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:
    Vec2i m_min;
    Vec2i m_max;
private:
    Vec2i m_countXY;

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

inline void SwapEndianness(Kaim::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 Kaim::Box2i& v)
{
    os << "{" << v.Min() << ";" << v.Max() << "}";
    return os;
}


} // namespace Kaim


#endif