vee_bounding_box.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_BOUNDING_BOX_H
#define VEE_BOUNDING_BOX_H

#include <vee_vector3.h>
#include <vee_matrix4.h>

class VEE_BoundingBox
{
public:
  VEE_BoundingBox() {}
  VEE_BoundingBox(const VEE_Vector3 * lowHigh) 
    : m_low(*lowHigh), m_high(*lowHigh) {}
  VEE_BoundingBox(const VEE_Vector3 & low, const VEE_Vector3 & high) 
    : m_low(low), m_high(high) {}
  ~VEE_BoundingBox() {}

  void scale(float v) { m_low = m_low * v; m_high = m_high * v; }
  inline void scale(const VEE_Vector3 &v);
  void move(const VEE_Vector3 &v) { m_low += v; m_high += v; }

  void clear() { m_low = m_high = VEE_Vector3ZERO; }
  void clear(const VEE_Vector3 &v) { m_low = m_high = v; }

  inline void expand(const VEE_Vector3 &v);
  inline void expand(const VEE_Vector3 &v, float radius);
  inline void expand(const VEE_BoundingBox &b);

  VEE_Vector3 & low() { return m_low; }
  const VEE_Vector3 & low() const { return m_low; }
  VEE_Vector3 & high() { return m_high; }
  const VEE_Vector3 & high() const { return m_high; }

  void set(float lx, float ly, float lz, float hx, float hy, float hz)
  { m_low.make(lx, ly, lz); m_high.make(hx, hy, hz); }

  void set(const VEE_Vector3 &low, const VEE_Vector3 &high)
  { m_low = low; m_high = high; }

  void set(const VEE_Vector3 * begin, const VEE_Vector3 *end)
  { set(*begin); while(begin != end) expand(*begin++);  }

  void set(const VEE_Vector3 &point)
  { m_low = m_high = point; }

  void set(const VEE_Vector3 &point, float radius)
  { m_low = point - radius; m_high = point + radius; }
  
  inline VEE_Vector3 center() const { return (m_low + m_high) * 0.5f; }
  inline float centerX() const { return (m_low.x + m_high.x) * 0.5f; }
  inline float centerY() const { return (m_low.y + m_high.y) * 0.5f; }
  inline float centerZ() const { return (m_low.z + m_high.z) * 0.5f; }
  inline VEE_Vector3 span() const { return m_high - m_low; }
  inline VEE_Vector3 topCenter() const;

  inline bool intersects(const VEE_BoundingBox &) const;
  inline bool contains(const VEE_Vector3 &) const;
  inline bool contains(const VEE_BoundingBox &b) const;
  
  inline VEE_Vector3 clamp(const VEE_Vector3 &) const;
  inline float axisDistance(const VEE_Vector3 &) const;
  
protected:
  VEE_Vector3 m_low, m_high;
};

inline void VEE_BoundingBox::expand(const VEE_Vector3 &v)
{
  if(v[0] < m_low[0]) m_low[0] = v[0];
  if(v[1] < m_low[1]) m_low[1] = v[1];
  if(v[2] < m_low[2]) m_low[2] = v[2];

  if(v[0] > m_high[0]) m_high[0] = v[0];
  if(v[1] > m_high[1]) m_high[1] = v[1];
  if(v[2] > m_high[2]) m_high[2] = v[2];
}

inline void VEE_BoundingBox::expand(const VEE_Vector3 &v, float radius)
{
  expand(v - VEE_Vector3(radius));
  expand(v + VEE_Vector3(radius));
}

inline void VEE_BoundingBox::expand(const VEE_BoundingBox &b)
{
  if(b.m_low[0] < m_low[0]) m_low[0] = b.m_low[0];
  if(b.m_low[1] < m_low[1]) m_low[1] = b.m_low[1];
  if(b.m_low[2] < m_low[2]) m_low[2] = b.m_low[2];

  if(b.m_high[0] > m_high[0]) m_high[0] = b.m_high[0];
  if(b.m_high[1] > m_high[1]) m_high[1] = b.m_high[1];
  if(b.m_high[2] > m_high[2]) m_high[2] = b.m_high[2];
}

void VEE_BoundingBox::scale(const VEE_Vector3 &v)
{
  m_low[0] *= v[0];
  m_low[1] *= v[1];
  m_low[2] *= v[2];

  m_high[0] *= v[0];
  m_high[1] *= v[1];
  m_high[2] *= v[2];
}

VEE_Vector3 VEE_BoundingBox::topCenter() const
{ 
  return VEE_Vector3((m_low.x + m_high.x) * 0.5,
         m_high.y,
         (m_low.z + m_high.z) * 0.5);
}

bool VEE_BoundingBox::intersects(const VEE_BoundingBox &b) const
{
  for(int i=0; i < 3; i++) {
    if(b.m_high[i] < m_low[i] || b.m_low[i] > m_high[i])
      return false;
  }

  return true;
}

inline bool VEE_BoundingBox::contains(const VEE_Vector3 &v) const
{
  return ((v[0] >= m_low[0]) && (v[0] <= m_high[0]) &&
    (v[1] >= m_low[1]) && (v[1] <= m_high[1]) && 
    (v[2] >= m_low[2]) && (v[2] <= m_high[2]));  
}

inline bool VEE_BoundingBox::contains(const VEE_BoundingBox &b) const
{
  return ((b.m_low[0] >= m_low[0]) && (b.m_high[0] <= m_high[0]) &&
    (b.m_low[1] >= m_low[1]) && (b.m_high[1] <= m_high[1]) && 
    (b.m_low[2] >= m_low[2]) && (b.m_high[2] <= m_high[2]));
}

inline VEE_Vector3 VEE_BoundingBox::clamp(const VEE_Vector3 &v) const
{
  int i;
  VEE_Vector3 r(v);

  for(i=0; i < 3; i++)
    if(r[i] < m_low[i]) r[i] = m_low[i];

  for(i=0; i < 3; i++)
    if(r[i] > m_high[i]) r[i] = m_high[i];

  return r;
}

inline float VEE_BoundingBox::axisDistance(const VEE_Vector3 &l) const
{
  VEE_Vector3 d;

  for(int i = 0; i < 3; i++) {
    if(l[i] > m_high[i])
      d[i] = l[i] - m_high[i];
    else if(l[i] < m_low[i])
      d[i] = m_low[i] - l[i];
    else
      d[i] = 0.0f;
  }

  return d.maximum();
}


template <class M>
inline VEE_BoundingBox operator * (const M &m, const VEE_BoundingBox &b)
{
  VEE_Vector3 tmp, low = b.low(), high = b.high();

  VEE_BoundingBox box;
  box.set(m * low);
  
  for(uint x = 0; x < 2; x++) {
    for(uint y = 0; y < 2; y++) {
      for(uint z = 0; z < 2; z++) {
  tmp.x = x ? low.x : high.x;
  tmp.y = y ? low.y : high.y;
  tmp.z = z ? low.z : high.z;

  box.expand(m * tmp);
  
      }
    }
  }

  return box;
}

#endif

---