aabbox3d.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#ifndef __IRR_AABBOX_3D_H_INCLUDED__
#define __IRR_AABBOX_3D_H_INCLUDED__
 
#include "plane3d.h"
#include "line3d.h"
 
namespace saga
{
namespace core
{
 
 
template <class T>
class aabbox3d
{
  public:
 
    aabbox3d(): MinEdge(-1,-1,-1), MaxEdge(1,1,1) {}
    aabbox3d(const glm::vec3& min, const glm::vec3& max): MinEdge(min), MaxEdge(max) {}
    aabbox3d(const glm::vec3& init): MinEdge(init), MaxEdge(init) {}
    aabbox3d(T minx, T miny, T minz, T maxx, T maxy, T maxz): MinEdge(minx, miny, minz), MaxEdge(maxx, maxy, maxz) {}
 
    // operators
 
    inline bool operator==(const aabbox3d<T>& other) const { return (MinEdge == other.MinEdge && other.MaxEdge == MaxEdge);}
 
    inline bool operator!=(const aabbox3d<T>& other) const { return !(MinEdge == other.MinEdge && other.MaxEdge == MaxEdge);}
 
    // functions
 
 
    void reset(T x, T y, T z)
    {
      MaxEdge = { x,y,z };
      MinEdge = MaxEdge;
    }
 
 
    void reset(const aabbox3d<T>& initValue)
    {
      *this = initValue;
    }
 
 
    void reset(const glm::vec3& initValue)
    {
      MaxEdge = initValue;
      MinEdge = initValue;
    }
 
 
    void addInternalPoint(const glm::vec3& p)
    {
      addInternalPoint(p.x, p.y, p.z);
    }
 
 
    void addInternalBox(const aabbox3d<T>& b)
    {
      addInternalPoint(b.MaxEdge);
      addInternalPoint(b.MinEdge);
    }
 
 
    void addInternalPoint(T x, T y, T z)
    {
      if (x>MaxEdge.x) MaxEdge.x = x;
      if (y>MaxEdge.y) MaxEdge.y = y;
      if (z>MaxEdge.z) MaxEdge.z = z;
 
      if (x<MinEdge.x) MinEdge.x = x;
      if (y<MinEdge.y) MinEdge.y = y;
      if (z<MinEdge.z) MinEdge.z = z;
    }
 
 
    glm::vec3 getCenter() const
    {
      return (MinEdge + MaxEdge) * 0.5f;
    }
 
 
    glm::vec3 getExtent() const
    {
      return MaxEdge - MinEdge;
    }
 
 
    T getRadius() const
    {
      const T radius = getExtent().getLength() / 2;
      return radius;
    }
 
 
    bool isEmpty() const
    {
      return glm::all(glm::equal(MinEdge, MaxEdge));
    }
 
    T getVolume() const
    {
      const glm::vec3 e = getExtent();
      return e.x * e.y * e.z;
    }
 
    T getArea() const
    {
      const glm::vec3 e = getExtent();
      return 2*(e.x*e.y + e.x*e.z + e.y*e.z);
    }
 
 
    void getEdges(glm::vec3 *edges) const
    {
      const glm::vec3 middle = getCenter();
      const glm::vec3 diag = middle - MaxEdge;
 
      /*
      Edges are stored in this way:
      Hey, am I an ascii artist, or what? :) niko.
                   /3--------/7
                  / |       / |
                 /  |      /  |
                1---------5   |
                |  /2- - -|- -6
                | /       |  /
                |/        | /
                0---------4/
      */
 
      edges[0] = { middle.x + diag.x, middle.y + diag.y, middle.z + diag.z };
      edges[1] = { middle.x + diag.x, middle.y - diag.y, middle.z + diag.z };
      edges[2] = { middle.x + diag.x, middle.y + diag.y, middle.z - diag.z };
      edges[3] = { middle.x + diag.x, middle.y - diag.y, middle.z - diag.z };
      edges[4] = { middle.x - diag.x, middle.y + diag.y, middle.z + diag.z };
      edges[5] = { middle.x - diag.x, middle.y - diag.y, middle.z + diag.z };
      edges[6] = { middle.x - diag.x, middle.y + diag.y, middle.z - diag.z };
      edges[7] = { middle.x - diag.x, middle.y - diag.y, middle.z - diag.z };
    }
 
 
    void repair()
    {
      T t;
 
      if (MinEdge.x > MaxEdge.x)
        { t=MinEdge.x; MinEdge.x = MaxEdge.x; MaxEdge.x=t; }
      if (MinEdge.y > MaxEdge.y)
        { t=MinEdge.y; MinEdge.y = MaxEdge.y; MaxEdge.y=t; }
      if (MinEdge.z > MaxEdge.z)
        { t=MinEdge.z; MinEdge.z = MaxEdge.z; MaxEdge.z=t; }
    }
 
 
    aabbox3d<T> getInterpolated(const aabbox3d<T>& other, float d) const
    {
      float inv = 1.0f - d;
      return aabbox3d<T>((other.MinEdge*inv) + (MinEdge*d),
        (other.MaxEdge*inv) + (MaxEdge*d));
    }
 
 
    bool isPointInside(const glm::vec3& p) const
    {
      return (p.x >= MinEdge.x && p.x <= MaxEdge.x &&
        p.y >= MinEdge.y && p.y <= MaxEdge.y &&
        p.z >= MinEdge.z && p.z <= MaxEdge.z);
    }
 
 
    bool isPointTotalInside(const glm::vec3& p) const
    {
      return (p.x > MinEdge.x && p.x < MaxEdge.x &&
        p.y > MinEdge.y && p.y < MaxEdge.y &&
        p.z > MinEdge.z && p.z < MaxEdge.z);
    }
 
 
    bool isFullInside(const aabbox3d<T>& other) const
    {
      return (MinEdge.x >= other.MinEdge.x && MinEdge.y >= other.MinEdge.y && MinEdge.z >= other.MinEdge.z &&
        MaxEdge.x <= other.MaxEdge.x && MaxEdge.y <= other.MaxEdge.y && MaxEdge.z <= other.MaxEdge.z);
    }
 
    aabbox3d<T> intersect(const aabbox3d<T>& other) const
    {
      aabbox3d<T> out;
 
      if (!intersectsWithBox(other))
        return out;
 
      out.MaxEdge.x = min_(MaxEdge.x, other.MaxEdge.x);
      out.MaxEdge.y = min_(MaxEdge.y, other.MaxEdge.y);
      out.MaxEdge.z = min_(MaxEdge.z, other.MaxEdge.z);
 
      out.MinEdge.x = max_(MinEdge.x, other.MinEdge.x);
      out.MinEdge.y = max_(MinEdge.y, other.MinEdge.y);
      out.MinEdge.z = max_(MinEdge.z, other.MinEdge.z);
 
      return out;
    }
 
 
    bool intersectsWithBox(const aabbox3d<T>& other) const
    {
      return (MinEdge.x <= other.MaxEdge.x && MinEdge.y <= other.MaxEdge.y && MinEdge.z <= other.MaxEdge.z &&
        MaxEdge.x >= other.MinEdge.x && MaxEdge.y >= other.MinEdge.y && MaxEdge.z >= other.MinEdge.z);
    }
 
 
    bool intersectsWithLine(const line3d<T>& line) const
    {
      return intersectsWithLine(line.getMiddle(), line.getVector().normalize(),
          (T)(line.getLength() * 0.5));
    }
 
 
    bool intersectsWithLine(const glm::vec3& linemiddle,
          const glm::vec3& linevect, T halflength) const
    {
      const glm::vec3 e = getExtent() * (T)0.5;
      const glm::vec3 t = getCenter() - linemiddle;
 
      if ((fabs(t.x) > e.x + halflength * fabs(linevect.x)) ||
        (fabs(t.y) > e.y + halflength * fabs(linevect.y)) ||
        (fabs(t.z) > e.z + halflength * fabs(linevect.z)))
        return false;
 
      T r = e.y * (T)fabs(linevect.z) + e.z * (T)fabs(linevect.y);
      if (fabs(t.y*linevect.z - t.z*linevect.y) > r)
        return false;
 
      r = e.x * (T)fabs(linevect.z) + e.z * (T)fabs(linevect.x);
      if (fabs(t.z*linevect.x - t.x*linevect.z) > r)
        return false;
 
      r = e.x * (T)fabs(linevect.y) + e.y * (T)fabs(linevect.x);
      if (fabs(t.x*linevect.y - t.y*linevect.x) > r)
        return false;
 
      return true;
    }
 
 
    EIntersectionRelation3D classifyPlaneRelation(const plane3d<T>& plane) const
    {
      glm::vec3 nearPoint(MaxEdge);
      glm::vec3 farPoint(MinEdge);
 
      if (plane.Normal.x > (T)0)
      {
        nearPoint.x = MinEdge.x;
        farPoint.x = MaxEdge.x;
      }
 
      if (plane.Normal.y > (T)0)
      {
        nearPoint.y = MinEdge.y;
        farPoint.y = MaxEdge.y;
      }
 
      if (plane.Normal.z > (T)0)
      {
        nearPoint.z = MinEdge.z;
        farPoint.z = MaxEdge.z;
      }
 
      if (plane.Normal.dotProduct(nearPoint) + plane.D > (T)0)
        return ISREL3D_FRONT;
 
      if (plane.Normal.dotProduct(farPoint) + plane.D > (T)0)
        return ISREL3D_CLIPPED;
 
      return ISREL3D_BACK;
    }
 
    glm::vec3 MinEdge;
 
    glm::vec3 MaxEdge;
};
 
  typedef aabbox3d<float> aabbox3df;
  typedef aabbox3d<std::int32_t> aabbox3di;
 
} // namespace core
} // namespace saga
 
#endif