box2f.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_Box2f_H
#define Navigation_Box2f_H

#include "gwnavruntime/math/box3f.h"

namespace Kaim
{

class Box2f
{
    KY_DEFINE_NEW_DELETE_OPERATORS(Stat_Default_Mem)

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

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


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

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

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

    KY_INLINE bool IsValid()
    {
        return m_min.x <= m_max.x && m_min.y <= m_max.y;
    }

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

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

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

    void ExpandByVec2(const Vec2f& pos)
    {
        const KyFloat32 posx = pos.x;
        const KyFloat32 posy = pos.y;
        m_min.x = Kaim::Min(m_min.x, posx);
        m_min.y = Kaim::Min(m_min.y, posy);
        m_max.x = Kaim::Max(m_max.x, posx);
        m_max.y = Kaim::Max(m_max.y, posy);
    }

    void ExpandByVec3(const Vec3f& pos)
    {
        const KyFloat32 posx = pos.x;
        const KyFloat32 posy = pos.y;
        m_min.x = Kaim::Min(m_min.x, posx);
        m_min.y = Kaim::Min(m_min.y, posy);
        m_max.x = Kaim::Max(m_max.x, posx);
        m_max.y = Kaim::Max(m_max.y, posy);
    }

    void ExpandByBox2(const Box2f& 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 ExpandByBox3(const Box3f& 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)
    {
        m_min.x -= enlargement;
        m_max.x += enlargement;
        m_min.y -= enlargement;
        m_max.y += enlargement;
    }

    KY_INLINE bool IsPoint2DInside(const Vec2f& p) const {
        const KyFloat32 operand1 = Fsel(p.x - m_min.x, 1.f, 0.f); // operand1 == 1.f if pos.x >= cellBox.m_min.x
        const KyFloat32 operand2 = Fsel(m_max.x - p.x, 1.f, 0.f); // operand2 == 1.f if cellBox.m_max.x >= pos.x
        const KyFloat32 operand3 = Fsel(p.y - m_min.y, 1.f, 0.f); // operand3 == 1.f if pos.y >= cellBox.m_min.y
        const KyFloat32 operand4 = Fsel(m_max.y - p.y, 1.f, 0.f); // operand4 == 1.f if cellBox.m_max.y >= pos.y
        return operand1 * operand2 * operand3 * operand4 > 0.f;
    }
    
    KY_INLINE bool IsPoint3DInside(const Vec3f& p) const
    {
        const KyFloat32 operand1 = Fsel(p.x - m_min.x, 1.f, 0.f); // operand1 == 1.f if pos.x >= cellBox.m_min.x
        const KyFloat32 operand2 = Fsel(m_max.x - p.x, 1.f, 0.f); // operand2 == 1.f if cellBox.m_max.x >= pos.x
        const KyFloat32 operand3 = Fsel(p.y - m_min.y, 1.f, 0.f); // operand3 == 1.f if pos.y >= cellBox.m_min.y
        const KyFloat32 operand4 = Fsel(m_max.y - p.y, 1.f, 0.f); // operand4 == 1.f if cellBox.m_max.y >= pos.y
        return operand1 * operand2 * operand3 * operand4 > 0.f;
    }

public:
    Vec2f m_min; //< Stores the minima of the box.
    Vec2f m_max; //< Stores the maxima of the box.
};

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


}


#endif