aabb3.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
AABB3::AABB3() {
    Invalidate();
}

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

inline
AABB3::AABB3(const Point3 &min, const Point3 &max) :
    m_min(min),
    m_max(max) {}

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

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

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

inline
void AABB3::Include(const Point3 &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;
    if(point.m_z < m_min.m_z) m_min.m_z = point.m_z;
    if(point.m_z > m_max.m_z) m_max.m_z = point.m_z;
}

inline
void AABB3::Include(const AABB3 &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_min.m_z < m_min.m_z) m_min.m_z = aabb.m_min.m_z;
    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;
    if(aabb.m_max.m_z > m_max.m_z) m_max.m_z = aabb.m_max.m_z;
}

inline
void AABB3::Intersect(const AABB3 &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_min.m_z > m_min.m_z) m_min.m_z = aabb.m_min.m_z;
    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;
    if(aabb.m_max.m_z < m_max.m_z) m_max.m_z = aabb.m_max.m_z;
}

inline
bool AABB3::Overlaps(const AABB3 &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 ||
        aabb.m_max.m_z <= m_min.m_z ||
        aabb.m_min.m_z >= m_max.m_z);
}

inline
bool AABB3::Contains(const Point3 &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 &&
        point.m_z >= m_min.m_z &&
        point.m_z <= m_max.m_z;
}

inline
Point3 AABB3::GetCenter() const {
    return 0.5 * (m_min + m_max);
}

inline
Vector3 AABB3::GetSize() const {
    return m_max - m_min;
}

inline
void AABB3::Scale(const Vector3 &scale) {
    const Point3 center = 0.5 * (m_min + m_max);
    const Vector3 delta = m_max - center;

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

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

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

---