aabb2.inl

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

inline
AABB2::AABB2() {
    Invalidate();
}

inline
AABB2::AABB2(const AABB2 &aabb) :
    m_min(aabb.m_min),
    m_max(aabb.m_max) {}

inline
AABB2::AABB2(const Point2 &min, const Point2 &max) :
    m_min(min),
    m_max(max) {}

inline
AABB2 AABB2::Biggest() {
    return AABB2(
        Point2(-std::numeric_limits<Real>::max()),
        Point2(std::numeric_limits<Real>::max()));
}

inline
void AABB2::Invalidate() {
    m_min = Point2(std::numeric_limits<Real>::max());
    m_max = Point2(-std::numeric_limits<Real>::max());
}

inline
bool AABB2::IsValid() const {
    return
        m_min.m_x <= m_max.m_x &&
        m_min.m_y <= m_max.m_y;
}

inline
void AABB2::Include(const Point2 &point) {
    if(point.m_x < m_min.m_x) m_min.m_x = point.m_x;
    if(point.m_x > m_max.m_x) m_max.m_x = point.m_x;
    if(point.m_y < m_min.m_y) m_min.m_y = point.m_y;
    if(point.m_y > m_max.m_y) m_max.m_y = point.m_y;
}

inline
void AABB2::Include(const AABB2 &aabb) {
    if(aabb.m_min.m_x < m_min.m_x) m_min.m_x = aabb.m_min.m_x;
    if(aabb.m_min.m_y < m_min.m_y) m_min.m_y = aabb.m_min.m_y;
    if(aabb.m_max.m_x > m_max.m_x) m_max.m_x = aabb.m_max.m_x;
    if(aabb.m_max.m_y > m_max.m_y) m_max.m_y = aabb.m_max.m_y;
}

inline
void AABB2::Intersect(const AABB2 &aabb) {
    if(aabb.m_min.m_x > m_min.m_x) m_min.m_x = aabb.m_min.m_x;
    if(aabb.m_min.m_y > m_min.m_y) m_min.m_y = aabb.m_min.m_y;
    if(aabb.m_max.m_x < m_max.m_x) m_max.m_x = aabb.m_max.m_x;
    if(aabb.m_max.m_y < m_max.m_y) m_max.m_y = aabb.m_max.m_y;
}

inline
bool AABB2::Overlaps(const AABB2 &aabb) const {
    return !(
        aabb.m_max.m_x <= m_min.m_x ||
        aabb.m_min.m_x >= m_max.m_x ||
        aabb.m_max.m_y <= m_min.m_y ||
        aabb.m_min.m_y >= m_max.m_y);
}

inline
bool AABB2::Contains(const Point2 &point) const {
    return
        point.m_x >= m_min.m_x &&
        point.m_x <= m_max.m_x &&
        point.m_y >= m_min.m_y &&
        point.m_y <= m_max.m_y;
}

inline
Point2 AABB2::GetCenter() const {
    return 0.5 * (m_min + m_max);
}

inline
Vector2 AABB2::GetSize() const {
    return m_max - m_min;
}

inline
void AABB2::Scale(const Vector2 &scale) {
    const Point2 center = 0.5 * (m_min + m_max);
    const Vector2 delta = m_max - center;

    const Vector2 shift(
        scale.m_x * delta.m_x,
        scale.m_y * delta.m_y);

    m_min = center - shift;
    m_max = center + shift;
}

inline
void AABB2::Extend(const Vector2 &ext) {
    m_min -= ext;
    m_max += ext;
}

---