box2f.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/vec2f.h"

namespace Kaim
{

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

    Box2f() { Clear(); } 
    Box2f(const Vec2f& _min, const Vec2f& _max) : m_min(_min), m_max(_max) {}
    Box2f(KyFloat32 min_x, KyFloat32 min_y, KyFloat32 max_x, KyFloat32 max_y) : m_min(min_x, min_y), m_max(max_x, max_y) {}

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

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

    bool IsValid() const { return m_min <= m_max; }

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

    void Set(KyFloat32 min_x, KyFloat32 min_y, KyFloat32 max_x, KyFloat32 max_y)
    {
        m_min.x = min_x;
        m_min.y = min_y;
        m_max.x = max_x;
        m_max.y = max_y;
    }

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

    KyFloat32 SizeX() { return m_max.x - m_min.x; } 
    KyFloat32 SizeY() { return m_max.y - m_min.y; } 

    template<typename T>
    void ExpandByPos(const T& pos)
    {
        m_min.x = Kaim::Min(m_min.x, pos.x);
        m_min.y = Kaim::Min(m_min.y, pos.y);
        m_max.x = Kaim::Max(m_max.x, pos.x);
        m_max.y = Kaim::Max(m_max.y, pos.y);
    }

    template<typename T>
    void ExpandByBox(const T& 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(KyFloat32 enlargement)
    {
        Vec2f e(enlargement, enlargement);
        m_min -= e;
        m_max += e;
    }

    template <typename T>
    bool DoesContain(const T& P) const { return P.x >= m_min.x && P.x <= m_max.x && P.y >= m_min.y && P.y <= m_max.y; }

    template <typename T>
    bool DoesContainStrictly(const T& P) const { return P.x > m_min.x && P.x < m_max.x && P.y > m_min.y && P.y < m_max.y; }

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

    Vec2f m_min;
    Vec2f m_max;
};

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

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

}