cs237-aabb.hpp

Go to the documentation of this file.

 
/*
 * COPYRIGHT (c) 2023 John Reppy (http://cs.uchicago.edu/~jhr)
 * All rights reserved.
 */
 
#ifndef _CS237_AABB_HPP_
#define _CS237_AABB_HPP_
 
#ifndef _CS237_HPP_
#  error "cs237-aabb.hpp should not be included directly"
#endif
 
namespace cs237 {
 
namespace __detail {
 
template <typename T>
struct AABB {
    using vec3 = glm::vec<3, T, glm::defaultp>;
 
    vec3 _min, _max;
    bool _empty;
 
    AABB () : _min(), _max(), _empty(true) {}
    AABB (AABB const & bbox) : _min(bbox._min), _max(bbox._max), _empty(bbox._empty) {}
    AABB (vec3 const &pt) : _min(pt), _max(pt), _empty(false) {}
    AABB (vec3 const &min, vec3 const &max) : _min(min), _max(max), _empty(false) {}
 
    bool isEmpty () const { return this->_empty; }
 
    void clear () { this->_empty = true; }
 
    bool includesPt (vec3 const &pt) const
    {
        return (! this->_empty)
            && (this->_min.x <= pt.x) && (pt.x <= this->_max.x)
            && (this->_min.y <= pt.y) && (pt.y <= this->_max.y)
            && (this->_min.z <= pt.z) && (pt.z <= this->_max.z);
    }
 
    T distanceToPt (vec3 const &pt) const
    {
#define DELTA(A)                            \
        (pt.A < this->_min.A)                       \
            ? (this->_min.A - pt.A)                 \
            : ((this->_max.A < pt.A) ? (pt.A - this->_max.A) : T(0))
 
        vec3 dv(DELTA(x), DELTA(y), DELTA(z));
        T lenSq = dot(dv, dv);
        if (lenSq == 0.0)
            return lenSq;
        else
            return sqrt(lenSq);
#undef DELTA
    }
 
    void addPt (vec3 const &pt)
    {
        if (this->_empty) {
            this->_empty = false;
            this->_min = pt;
            this->_max = pt;
        }
        else if (pt.x < this->_min.x) this->_min.x = pt.x;
        else if (this->_max.x < pt.x) this->_max.x = pt.x;
        if (pt.y < this->_min.y) this->_min.y = pt.y;
        else if (this->_max.y < pt.y) this->_max.y = pt.y;
        if (pt.z < this->_min.z) this->_min.z = pt.z;
        else if (this->_max.z < pt.z) this->_max.z = pt.z;
    }
 
    AABB & operator+= (AABB const &bb)
    {
        if ((! this->_empty) && (! bb._empty)) {
            this->_min = glm::min(this->_min, bb._min);
            this->_max = glm::min(this->_max, bb._max);
        }
        else if (this->_empty) {
            this->_empty = false;
            this->_min = bb._min;
            this->_max = bb._max;
        }
 
        return *this;
    }
 
    AABB & operator+= (vec3 const &pt)
    {
        this->addPt (pt);
        return *this;
    }
 
  /***** Warning: the following functions are undefined on empty boxes! *****/
 
    vec3 const & min() const
    {
        assert (! this->_empty);
        return this->_min;
    }
 
    vec3 const & max() const
    {
        assert (! this->_empty);
        return this->_max;
    }
 
    vec3 center () const
    {
        assert (! this->_empty);
        return T(0.5) * (this->_min + this->_max);
    }
 
    T minX () const
    {
        assert (! this->_empty);
        return this->_min.x;
    }
    T minY () const
    {
        assert (! this->_empty);
        return this->_min.y;
    }
    T minZ () const
    {
        assert (! this->_empty);
        return this->_min.z;
    }
    T maxX () const
    {
        assert (! this->_empty);
        return this->_max.x;
    }
    T maxY () const
    {
        assert (! this->_empty);
        return this->_max.y;
    }
    T maxZ () const
    {
        assert (! this->_empty);
        return this->_max.z;
    }
 
    vec3 corner (int i) const
    {
        assert (! this->_empty);
        assert ((0 <= i) && (i < 8));
        return vec3(
            (i & 4) ? this->_max.x : this->_min.x,
            (i & 2) ? this->_max.y : this->_min.y,
            (i & 1) ? this->_max.z : this->_min.z);
    }
 
    std::array<vec3,8> corners () const
    {
        return std::array<vec3,8>{
                vec3(this->_min.x, this->_min.y, this->_min.z),
                vec3(this->_min.x, this->_min.y, this->_max.z),
                vec3(this->_min.x, this->_max.y, this->_min.z),
                vec3(this->_min.x, this->_max.y, this->_max.z),
                vec3(this->_max.x, this->_min.y, this->_min.z),
                vec3(this->_max.x, this->_min.y, this->_max.z),
                vec3(this->_max.x, this->_max.y, this->_min.z),
                vec3(this->_max.x, this->_max.y, this->_max.z)
            };
    }
};
 
template <typename T>
std::ostream& operator<< (std::ostream& s, __detail::AABB<T> const &bb);
 
template <typename T>
inline AABB<T> operator+ (AABB<T> const &bb1, AABB<T> &bb2)
{
    if ((! bb1._empty) && (! bb2.empty)) {
        return AABB<T>(glm::min(bb1._min, bb2._min), glm::max(bb1._min, bb2._min));
    }
    else if (bb1.empty) {
        return bb2;
    } else {
        return bb1;
    }
}
 
} // namespace __detail
 
using AABBf_t = __detail::AABB<float>;
using AABBd_t = __detail::AABB<double>;
 
} //namespace cs237
 
#endif /* !_CS237_AABB_HPP_ */