box3f.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/vec3f.h"
#include "gwnavruntime/math/triangle3f.h"

namespace Kaim
{

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

    Box3f() { Clear(); } 
    Box3f(const Vec3f& min_, const Vec3f& max_) : m_min(min_), m_max(max_) {}
    Box3f(const Vec3f& center, KyFloat32 extent) : m_min(center), m_max(center) { Enlarge(extent); }

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

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

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

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

    void Set(const Vec3f& center, KyFloat32 halfSize)
    {
        m_min = center;
        m_max = center;
        Enlarge(halfSize);
    }

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

    Vec3f Center() const { return (m_min + m_max) * 0.5f; }

    KyFloat32 BoundingSphereRadius() const { return Vec3f(SizeX(), SizeY(), SizeZ()).Length() * 0.5f; }

    void Translate(const Vec3f& v) { m_min += v; m_max += v; }

    Box3f GetTranslated(const Vec3f& v) const { return Box3f(m_min + v, m_max + v); }

    void ExpandByTriangle(const Triangle3f& triangle)
    {
        ExpandByPos(triangle.A);
        ExpandByPos(triangle.B);
        ExpandByPos(triangle.C);
    }

    void ExpandByPos(const Vec3f& pos)
    {
        m_min.x = Kaim::Min(m_min.x, pos.x);
        m_min.y = Kaim::Min(m_min.y, pos.y);
        m_min.z = Kaim::Min(m_min.z, pos.z);
        m_max.x = Kaim::Max(m_max.x, pos.x);
        m_max.y = Kaim::Max(m_max.y, pos.y);
        m_max.z = Kaim::Max(m_max.z, pos.z);
    }

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

    void Enlarge(KyFloat32 enlargement)
    {
        Vec3f e(enlargement, enlargement, enlargement);
        m_min -= e;
        m_max += e;
    }

    bool DoesContain(const Vec2f& P)         const { return LessEq(m_min.x, P.x, m_max.x) && LessEq(m_min.y, P.y, m_max.y); }
    bool DoesContainStrictly(const Vec2f& P) const { return Less(m_min.x, P.x, m_max.x) && Less(m_min.y, P.y, m_max.y); }

    bool DoesContain(const Vec3f& P)         const { return LessEq(m_min.x, P.x, m_max.x) && LessEq(m_min.y, P.y, m_max.y) && LessEq(m_min.z, P.z, m_max.z); }
    bool DoesContainStrictly(const Vec3f& P) const { return Less(m_min.x, P.x, m_max.x) && Less(m_min.y, P.y, m_max.y) && Less(m_min.z, P.z, m_max.z); }

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

    Vec3f m_min;
    Vec3f m_max;
};

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

template <class OSTREAM>
inline OSTREAM& operator<<(OSTREAM& os, const Box3f& self)
{
    os << "{" << self.m_min << "," << self.m_max << "}";
    return os;
}

}